Cataclysm BN
game Class Reference

#include <game.h>

Classes

class  Creature_range
 
class  debug_hour_timer
 
class  draw_callback_t
 
class  monster_range
 
class  non_dead_range
 
class  npc_range
 

Public Types

enum  inventory_item_menu_positon { RIGHT_TERMINAL_EDGE , LEFT_OF_INFO , RIGHT_OF_INFO , LEFT_TERMINAL_EDGE }
 

Public Member Functions

 game ()
 
 ~game ()
 
void load_static_data ()
 Loads static data that does not depend on mods or similar. More...
 
void load_core_data (loading_ui &ui)
 Loads core dynamic data. More...
 
bool is_core_data_loaded () const
 Returns whether the core data is currently loaded. More...
 
bool check_mod_data (const std::vector< mod_id > &opts, loading_ui &ui)
 Check if mods can be successfully loaded. More...
 
void load_world_modfiles (loading_ui &ui)
 Loads core data and mods from the active world. More...
 
std::string get_player_base_save_path () const
 Base path for saving player data. More...
 
std::string get_world_base_save_path () const
 Base path for saving world data. More...
 
bool load_packs (const std::string &msg, const std::vector< mod_id > &packs, loading_ui &ui)
 Load content packs. More...
 
void on_options_changed ()
 Should be invoked whenever options change. More...
 
void setup ()
 
void serialize (std::ostream &fout)
 Saving and loading functions. More...
 
void unserialize (std::istream &fin)
 
void unserialize_master (std::istream &fin)
 
bool dump_stats (const std::string &what, dump_mode mode, const std::vector< std::string > &opts)
 write statistics to stdout and More...
 
bool save ()
 Returns false if saving failed. More...
 
std::vector< std::string > list_active_characters ()
 Returns a list of currently active character saves. More...
 
void write_memorial_file (const std::string &filename, std::string sLastWords)
 Writes information about the character out to a text file timestamped with the time of the file was made. More...
 
bool cleanup_at_end ()
 
void start_calendar ()
 
bool do_turn ()
 MAIN GAME LOOP. More...
 
shared_ptr_fast< ui_adaptorcreate_or_get_main_ui_adaptor ()
 
void invalidate_main_ui_adaptor () const
 
void mark_main_ui_adaptor_resize () const
 
void draw ()
 
void draw_ter (bool draw_sounds=true)
 
void draw_ter (const tripoint &center, bool looking=false, bool draw_sounds=true)
 
void add_draw_callback (shared_ptr_fast< draw_callback_t > cb)
 
void draw_panels (bool force_draw=false)
 
cata::optional< tripointget_veh_dir_indicator_location (bool next) const
 Returns the location where the indicator should go relative to the reality bubble, or nothing to indicate no indicator should be drawn. More...
 
void draw_veh_dir_indicator (bool next)
 
void vertical_move (int z, bool force, bool peeking=false)
 Moves the player vertically. More...
 
void start_hauling (const tripoint &pos)
 
cata::optional< tripointfind_or_make_stairs (map &mp, int z_after, bool &rope_ladder, bool peeking)
 Returns the other end of the stairs (if any). More...
 
void vertical_shift (int z_after)
 Actual z-level movement part of vertical_move. More...
 
void vertical_notes (int z_before, int z_after)
 Add goes up/down auto_notes (if turned on) More...
 
void use_computer (const tripoint &p)
 Checks to see if a player can use a computer (not illiterate, etc.) and uses if able. More...
 
template<typename T = Creature>
T * critter_by_id (const character_id &id)
 
template<typename T = Creature>
T * critter_at (const tripoint &p, bool allow_hallucination=false)
 Returns the Creature at the given location. More...
 
template<typename T = Creature>
const T * critter_at (const tripoint &p, bool allow_hallucination=false) const
 
template<typename T = Creature>
shared_ptr_fast< T > shared_from (const T &critter)
 Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature). More...
 
size_t num_creatures () const
 Returns the approximate number of creatures in the reality bubble. More...
 
bool update_zombie_pos (const monster &critter, const tripoint &pos)
 Redirects to the creature_tracker update_pos() function. More...
 
void remove_zombie (const monster &critter)
 
void clear_zombies ()
 Redirects to the creature_tracker clear() function. More...
 
bool spawn_hallucination (const tripoint &p)
 Spawns a hallucination at a determined position. More...
 
bool swap_critters (Creature &, Creature &)
 Swaps positions of two creatures. More...
 
Creature_range all_creatures ()
 Returns an anonymous range that contains all creatures. More...
 
monster_range all_monsters ()
 Same as all_creatures but iterators only over monsters. More...
 
npc_range all_npcs ()
 Same as all_creatures but iterators only over npcs. More...
 
std::vector< Creature * > get_creatures_if (const std::function< bool(const Creature &)> &pred)
 Returns all creatures matching a predicate. More...
 
std::vector< npc * > get_npcs_if (const std::function< bool(const npc &)> &pred)
 
Creatureget_creature_if (const std::function< bool(const Creature &)> &pred)
 Returns a creature matching a predicate. More...
 
bool is_empty (const tripoint &p)
 Returns true if there is no player, NPC, or monster on the tile and move_cost > 0. More...
 
bool is_in_sunlight (const tripoint &p)
 Returns true if p is outdoors and it is sunny. More...
 
bool is_sheltered (const tripoint &p)
 Returns true if p is indoors, underground, or in a car. More...
 
bool revive_corpse (const tripoint &p, item &it)
 Revives a corpse at given location. More...
 
void save_cyborg (item *cyborg, const tripoint &couch_pos, player &installer)
 Turns Broken Cyborg monster into Cyborg NPC via surgery. More...
 
bool cancel_activity_query (const std::string &text)
 Asks if the player wants to cancel their activity, and if so cancels it. More...
 
bool cancel_activity_or_ignore_query (distraction_type type, const std::string &text)
 Asks if the player wants to cancel their activity and if so cancels it. More...
 
void moving_vehicle_dismount (const tripoint &dest_loc)
 Handles players exiting from moving vehicles. More...
 
vehicleremoteveh ()
 Returns the current remotely controlled vehicle. More...
 
void setremoteveh (vehicle *veh)
 Sets the current remotely controlled vehicle. More...
 
int assign_mission_id ()
 Returns the next available mission id. More...
 
npcfind_npc (character_id id)
 Find the npc with the given ID. More...
 
void load_npcs ()
 Makes any nearby NPCs on the overmap active. More...
 
void reload_npcs ()
 Unloads, then loads the NPCs. More...
 
const kill_trackerget_kill_tracker () const
 
void add_npc_follower (const character_id &id)
 Add follower id to set of followers. More...
 
void remove_npc_follower (const character_id &id)
 Remove follower id from follower set. More...
 
std::set< character_idget_follower_list ()
 Get set of followers. More...
 
void validate_npc_followers ()
 validate list of followers to account for overmap buffers More...
 
void validate_mounted_npcs ()
 
void validate_linked_vehicles ()
 validate towed vehicles so they get linked up again after a load More...
 
void validate_camps ()
 validate camps to ensure they are on the overmap list More...
 
void autopilot_vehicles ()
 process vehicles that are following the player More...
 
void catch_a_monster (monster *fish, const tripoint &pos, player *p, const time_duration &catch_duration)
 Picks and spawns a random fish from the remaining fish list when a fish is caught. More...
 
std::unordered_set< tripointget_fishable_locations (int distance, const tripoint &fish_pos)
 Get the contiguous fishable locations starting at fish_pos, out to the specificed distance. More...
 
std::vector< monster * > get_fishable_monsters (std::unordered_set< tripoint > &fishable_locations)
 Get the fishable monsters within the provided fishable locations. More...
 
void fling_creature (Creature *c, const units::angle &dir, float flvel, bool controlled=false, bool suppress_map_update=false)
 Flings the input creature in the given direction. More...
 
float natural_light_level (int zlev) const
 
unsigned char light_level (int zlev) const
 Returns coarse number-of-squares of visibility at the current light level. More...
 
void reset_light_level ()
 
character_id assign_npc_id ()
 
Creatureis_hostile_nearby ()
 
Creatureis_hostile_very_close ()
 
point update_map (player &p)
 
point update_map (int &x, int &y)
 
void update_overmap_seen ()
 
void process_artifact (item &it, player &p)
 
void add_artifact_messages (const std::vector< art_effect_passive > &effects)
 
void add_artifact_dreams ()
 
void peek ()
 
void peek (const tripoint &p)
 
cata::optional< tripointlook_debug ()
 
bool check_zone (const zone_type_id &type, const tripoint &where) const
 
bool check_near_zone (const zone_type_id &type, const tripoint &where) const
 Checks whether or not there is a zone of particular type nearby. More...
 
bool is_zones_manager_open () const
 
void zones_manager ()
 
cata::optional< tripointlook_around ()
 
look_around_result look_around (bool show_window, tripoint &center, const tripoint &start_point, bool has_first_point, bool select_zone, bool peeking, bool is_moving_zone=false, const tripoint &end_point=tripoint_zero)
 
void pre_print_all_tile_info (const tripoint &lp, const catacurses::window &w_info, int &line, int last_line, const visibility_variables &cache)
 
void print_all_tile_info (const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line, int last_line, const visibility_variables &cache)
 
void draw_look_around_cursor (const tripoint &lp, const visibility_variables &cache)
 
void extended_description (const tripoint &p)
 Long description of (visible) things at tile. More...
 
void draw_trail_to_square (const tripoint &t, bool bDrawX)
 
int inventory_item_menu (item_location locThisItem, const std::function< int()> &startx=[]() { return 0;}, const std::function< int()> &width=[]() { return 50;}, inventory_item_menu_positon position=RIGHT_OF_INFO)
 
item_location inv_map_splice (item_filter filter, const std::string &title, int radius=0, const std::string &none_message="")
 Custom-filtered menu for inventory and nearby items and those that within specified radius. More...
 
bool has_gametype () const
 
special_game_id gametype () const
 
void toggle_fullscreen ()
 
void toggle_pixel_minimap ()
 
void reload_tileset ()
 
void temp_exit_fullscreen ()
 
void reenter_fullscreen ()
 
void zoom_in ()
 
void zoom_out ()
 
void reset_zoom ()
 
void set_zoom (int level)
 
int get_zoom () const
 
int get_moves_since_last_save () const
 
int get_user_action_counter () const
 
bool take_screenshot (const std::string &file_path) const
 Saves a screenshot of the current viewport, as a PNG file, to the given location. More...
 
bool take_screenshot () const
 Saves a screenshot of the current viewport, as a PNG file. More...
 
int get_levx () const
 The top left corner of the reality bubble (in submaps coordinates). More...
 
int get_levy () const
 
int get_levz () const
 
void load_map (const tripoint &pos_sm)
 Load the main map at given location, see map::load, in global, absolute submap coordinates. More...
 
void load_map (const tripoint_abs_sm &pos_sm)
 
overmapget_cur_om () const
 The overmap which contains the center submap of the reality bubble. More...
 
std::vector< npc * > allies ()
 Get all living player allies. More...
 
void set_driving_view_offset (const point &p)
 
void calc_driving_offset (vehicle *veh=nullptr)
 
void open_gate (const tripoint &p)
 
void knockback (const tripoint &s, const tripoint &t, int force, int stun, int dam_mult)
 
void knockback (std::vector< tripoint > &traj, int stun, int dam_mult)
 
void draw_bullet (const tripoint &t, int i, const std::vector< tripoint > &trajectory, char bullet)
 
void draw_hit_mon (const tripoint &p, const monster &m, bool dead=false)
 
void draw_hit_player (const Character &p, int dam)
 
void draw_line (const tripoint &p, const tripoint &center_point, const std::vector< tripoint > &points, bool noreveal=false)
 
void draw_line (const tripoint &p, const std::vector< tripoint > &points)
 
void draw_weather (const weather_printable &wPrint)
 
void draw_sct ()
 
void draw_zones (const tripoint &start, const tripoint &end, const tripoint &offset)
 
void draw_critter (const Creature &critter, const tripoint &center)
 
void draw_critter_highlighted (const Creature &critter, const tripoint &center)
 
void draw_cursor (const tripoint &p)
 
void draw_highlight (const tripoint &p)
 
void draw_radiation_override (const tripoint &p, int rad)
 
void draw_terrain_override (const tripoint &p, const ter_id &id)
 
void draw_furniture_override (const tripoint &p, const furn_id &id)
 
void draw_graffiti_override (const tripoint &p, bool has)
 
void draw_trap_override (const tripoint &p, const trap_id &id)
 
void draw_field_override (const tripoint &p, const field_type_id &id)
 
void draw_item_override (const tripoint &p, const itype_id &id, const mtype_id &mid, bool hilite)
 
void draw_vpart_override (const tripoint &p, const vpart_id &id, int part_mod, units::angle veh_dir, bool hilite, const point &mount)
 
void draw_below_override (const tripoint &p, bool draw)
 
void draw_monster_override (const tripoint &p, const mtype_id &id, int count, bool more, Creature::Attitude att)
 
bool is_in_viewport (const tripoint &p, int margin=0) const
 
bool check_safe_mode_allowed (bool repeat_safe_mode_warnings=true)
 Check whether movement is allowed according to safe mode settings. More...
 
void set_safe_mode (safe_mode_type mode)
 
void exam_vehicle (vehicle &veh, const point &cp=point_zero)
 open vehicle interaction screen More...
 
bool forced_door_closing (const tripoint &p, const ter_id &door_type, int bash_dmg)
 
bool load (const std::string &world)
 Attempt to load first valid save (if any) in world. More...
 
bool npc_menu (npc &who)
 Returns true if the menu handled stuff and player shouldn't do anything else. More...
 
bool phasing_move (const tripoint &dest, bool via_ramp=false)
 
bool walk_move (const tripoint &dest, bool via_ramp=false)
 
void on_move_effects ()
 
void reload (item_location &loc, bool prompt=false, bool empty=true)
 
void reload_item ()
 
void reload_wielded (bool prompt=false)
 
void reload_weapon (bool try_everything=true)
 
point place_player (const tripoint &dest)
 
void place_player_overmap (const tripoint_abs_omt &om_dest)
 
bool unload (item_location loc)
 
unsigned int get_seed () const
 
void set_npcs_dirty ()
 If invoked, NPCs will be reloaded before next turn. More...
 
void set_critter_died ()
 If invoked, dead will be cleaned this turn. More...
 
void mon_info (const catacurses::window &, int hor_padding=0)
 
void mon_info_update ()
 
void cleanup_dead ()
 
bool is_dangerous_tile (const tripoint &dest_loc) const
 
std::vector< std::string > get_dangerous_tile (const tripoint &dest_loc) const
 
bool prompt_dangerous_tile (const tripoint &dest_loc) const
 
void despawn_monster (monster &critter)
 Despawn a specific monster, it's stored on the overmap. More...
 
void win ()
 Marks the game as won. More...
 
bool disable_robot (const tripoint &p)
 If there is a robot (that can be disabled), query the player and try to disable it. More...
 
void draw_pixel_minimap (const catacurses::window &w)
 
void quicksave ()
 
void disp_NPCs ()
 
void list_missions ()
 
event_busevents ()
 
stats_trackerstats ()
 
memorial_loggermemorial ()
 
spell_eventsspell_events_subscriber ()
 
void display_toggle_overlay (action_id)
 
bool display_overlay_state (action_id)
 
void toggle_debug_hour_timer ()
 
tripoint mouse_edge_scrolling_terrain (input_context &ctxt)
 Used to implement mouse "edge scrolling". More...
 
tripoint mouse_edge_scrolling_overmap (input_context &ctxt)
 This variant is suitable for the overmap. More...
 
void shift_destination_preview (const point &delta)
 
bool slip_down ()
 Checks if player is able to successfully climb to/from some terrain and not slip down. More...
 
monsterplace_critter_at (const mtype_id &id, const tripoint &p)
 Adds critters to the reality bubble, creating them if necessary. More...
 
monsterplace_critter_at (const shared_ptr_fast< monster > &mon, const tripoint &p)
 
monsterplace_critter_around (const mtype_id &id, const tripoint &center, int radius)
 
monsterplace_critter_around (const shared_ptr_fast< monster > &mon, const tripoint &center, int radius, bool forced=false)
 
monsterplace_critter_within (const mtype_id &id, const tripoint_range< tripoint > &range)
 
monsterplace_critter_within (const shared_ptr_fast< monster > &mon, const tripoint_range< tripoint > &range)
 

Public Attributes

mapm
 
avataru
 
scent_mapscent
 
timed_event_managertimed_events
 
pimpl< Creature_trackercritter_tracker
 
pimpl< faction_managerfaction_manager_ptr
 
pimpl< drop_token_providertoken_provider_ptr
 
quit_status uquit
 Used in main.cpp to determine what type of quit is being performed. More...
 
bool new_game = false
 True if the game has just started or loaded, else false. More...
 
const scenarioscen
 
std::vector< monstercoming_to_stairs
 
int monstairz = 0
 
tripoint ter_view_p
 
catacurses::window w_terrain
 
catacurses::window w_overmap
 
catacurses::window w_omlegend
 
catacurses::window w_minimap
 
catacurses::window w_pixel_minimap
 
point driving_view_offset
 
bool debug_pathfinding = false
 
bool debug_submap_grid_overlay = false
 
Creaturedisplaying_visibility_creature
 Creature for which to display the visibility map. More...
 
int displaying_lighting_condition = 0
 Type of lighting condition overlay to display. More...
 
bool show_panel_adm = false
 
bool right_sidebar = false
 
bool fullscreen = false
 
bool was_fullscreen = false
 
bool auto_travel_mode = false
 
bool queue_screenshot = false
 
safe_mode_type safe_mode
 
int turnssincelastmon = 0
 
int mostseen = 0
 

Protected Member Functions

void load_data_from_dir (const std::string &path, const std::string &src, loading_ui &ui)
 Loads dynamic data from the given directory. More...
 

Private Types

enum class  vmenu_ret : int { CHANGE_TAB , QUIT , FIRE }
 

Private Member Functions

void unload_npcs ()
 Unloads all NPCs. More...
 
bool load (const save_t &name)
 
void load_master ()
 
bool start_game ()
 
bool save_factions_missions_npcs ()
 
void reset_npc_dispositions ()
 
void serialize_master (std::ostream &fout)
 
bool save_artifacts ()
 
bool save_maps ()
 
void init_autosave ()
 
void create_starting_npcs ()
 
vehicleplace_vehicle_nearby (const vproto_id &id, const point_abs_omt &origin, int min_distance, int max_distance, const std::vector< std::string > &omt_search_types={})
 
void list_items_monsters ()
 
game::vmenu_ret list_items (const std::vector< map_item_stack > &item_list)
 
std::vector< map_item_stackfind_nearby_items (int iRadius)
 
void reset_item_list_state (const catacurses::window &window, int height, bool bRadiusSort)
 
game::vmenu_ret list_monsters (const std::vector< Creature * > &monster_list)
 
bool grabbed_move (const tripoint &dp)
 Check for dangerous stuff at dest_loc, return false if the player decides not to step there. More...
 
bool grabbed_veh_move (const tripoint &dp)
 
bool grabbed_furn_move (const tripoint &dp)
 
void control_vehicle ()
 
void examine (const tripoint &p)
 
void examine ()
 
void pickup ()
 
void pickup (const tripoint &p)
 
void pickup_feet ()
 
void drop ()
 
void drop_in_direction ()
 
void butcher ()
 
void wield ()
 
void wield (item_location &loc)
 
void chat ()
 
void print_fields_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line)
 
void print_terrain_info (const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line)
 
void print_trap_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line)
 
void print_creature_info (const Creature *creature, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_vehicle_info (const vehicle *veh, int veh_part, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_visibility_info (const catacurses::window &w_look, int column, int &line, visibility_type visibility)
 
void print_items_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_graffiti_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
 
input_context get_player_input (std::string &action)
 
void replace_stair_monsters ()
 
void update_stair_monsters ()
 
void shift_monsters (const tripoint &shift)
 Shift all active monsters, the shift vector is the number of shifted submaps. More...
 
void perhaps_add_random_npc ()
 
void monmove ()
 
void overmap_npc_move ()
 
void process_voluntary_act_interrupt ()
 
void process_activity ()
 
void handle_key_blocking_activity ()
 
void open_consume_item_menu ()
 
bool handle_action ()
 
bool try_get_right_click_action (action_id &act, const tripoint &mouse_target)
 
bool try_get_left_click_action (action_id &act, const tripoint &mouse_target)
 
void item_action_menu ()
 
bool is_game_over ()
 
void death_screen ()
 
void win_screen ()
 
void draw_minimap ()
 
void autosave ()
 
void quickload ()
 
bool handle_mouseview (input_context &ctxt, std::string &action)
 
void display_faction_epilogues ()
 
void disp_NPC_epilogues ()
 
void display_scent ()
 
void display_temperature ()
 
void display_vehicle_ai ()
 
void display_visibility ()
 
void display_lighting ()
 
void display_radiation ()
 
void display_transparency ()
 
Creatureis_hostile_within (int distance)
 
void move_save_to_graveyard (const std::string &dirname)
 
bool save_player_data ()
 
std::pair< tripoint, tripointmouse_edge_scrolling (input_context &ctxt, int speed, const tripoint &last, bool iso)
 

Private Attributes

bool is_looking = false
 
std::vector< weak_ptr_fast< draw_callback_t > > draw_callbacks
 
cata::optional< action_iddisplaying_overlays
 
class game::debug_hour_timer debug_hour_timer
 
pimpl< mapmap_ptr
 
pimpl< avataru_ptr
 
pimpl< live_viewliveview_ptr
 
live_viewliveview
 
pimpl< scent_mapscent_ptr
 
pimpl< timed_event_managertimed_event_manager_ptr
 
pimpl< event_busevent_bus_ptr
 
pimpl< stats_trackerstats_tracker_ptr
 
pimpl< achievements_trackerachievements_tracker_ptr
 
pimpl< kill_trackerkill_tracker_ptr
 
pimpl< memorial_loggermemorial_logger_ptr
 
pimpl< spell_eventsspell_events_ptr
 
pimpl< distribution_grid_trackergrid_tracker_ptr
 
pimpl< weather_managerweather_manager_ptr
 
shared_ptr_fast< playeru_shared_ptr
 
catacurses::window w_terrain_ptr
 
catacurses::window w_minimap_ptr
 
std::string sFilter
 
std::string list_item_upvote
 
std::string list_item_downvote
 
bool safe_mode_warning_logged = false
 
bool bVMonsterLookFire = false
 
character_id next_npc_id
 
std::list< shared_ptr_fast< npc > > active_npc
 
int next_mission_id = 0
 
std::set< character_idfollower_ids
 
int moves_since_last_save = 0
 
time_t last_save_timestamp
 
std::array< float, OVERMAP_LAYERSlatest_lightlevels
 
time_point remoteveh_cache_time
 
vehicleremoteveh_cache
 
bool npcs_dirty = false
 Has a NPC been spawned since last load? More...
 
bool critter_died = false
 Has anything died in this turn and needs to be cleaned up? More...
 
bool first_redraw_since_waiting_started = true
 Is this the first redraw since waiting (sleeping or activity) started. More...
 
bool zones_manager_open = false
 Is Zone manager open or not - changes graphics of some zone tiles. More...
 
std::unique_ptr< special_gamegamemode
 
int user_action_counter = 0
 
int tileset_zoom = 0
 How far the tileset should be zoomed out, 16 is default. More...
 
unsigned int seed = 0
 Seed for all the random numbers that should have consistent randomness (weather). More...
 
std::vector< tripointdestination_preview
 
std::chrono::time_point< std::chrono::steady_clock > last_mouse_edge_scroll
 
tripoint last_mouse_edge_scroll_vector_terrain
 
tripoint last_mouse_edge_scroll_vector_overmap
 
weak_ptr_fast< ui_adaptormain_ui_adaptor
 
std::unique_ptr< static_popupwait_popup
 

Friends

class editmap
 
class advanced_inventory
 
class main_menu
 
class monster_range
 
class Creature_range
 
distribution_grid_trackerget_distribution_grid_tracker ()
 Returns distribution grid tracker that is a part of the global game *g. More...
 
mapget_map ()
 
Characterget_player_character ()
 
avatarget_avatar ()
 
weather_managerget_weather ()
 

Detailed Description

Definition at line 143 of file game.h.

Member Enumeration Documentation

◆ inventory_item_menu_positon

Enumerator
RIGHT_TERMINAL_EDGE 
LEFT_OF_INFO 
RIGHT_OF_INFO 
LEFT_TERMINAL_EDGE 

Definition at line 611 of file game.h.

611 {
616 };
@ LEFT_OF_INFO
Definition: game.h:613
@ RIGHT_OF_INFO
Definition: game.h:614
@ RIGHT_TERMINAL_EDGE
Definition: game.h:612
@ LEFT_TERMINAL_EDGE
Definition: game.h:615

◆ vmenu_ret

enum class game::vmenu_ret : int
strongprivate
Enumerator
CHANGE_TAB 
QUIT 
FIRE 

Definition at line 805 of file game.h.

805 : int {
806 CHANGE_TAB,
807 QUIT,
808 FIRE, // Who knew, apparently you can do that in list_monsters
809 };

Constructor & Destructor Documentation

◆ game()

game::game ( )

Definition at line 286 of file game.cpp.

286 :
288 scent_ptr( *this ),
291 m( *map_ptr ),
292 u( *u_ptr ),
293 scent( *scent_ptr ),
295 uquit( QUIT_NO ),
296 new_game( false ),
298 mostseen( 0 ),
301 next_npc_id( 1 ),
302 next_mission_id( 1 ),
306 seed( 0 ),
307 last_mouse_edge_scroll( std::chrono::steady_clock::now() )
308{
316 world_generator = std::make_unique<worldfactory>();
317 // do nothing, everything that was in here is moved to init_data() which is called immediately after g = new game; in main.cpp
318 // The reason for this move is so that g is not uninitialized when it gets to installing the parts into vehicles.
319}
void subscribe(event_subscriber *)
Definition: event_bus.cpp:39
int mostseen
Definition: game.h:1071
pimpl< spell_events > spell_events_ptr
Definition: game.h:1006
safe_mode_type safe_mode
Definition: game.h:1068
bool safe_mode_warning_logged
Definition: game.h:1082
pimpl< timed_event_manager > timed_event_manager_ptr
Definition: game.h:1000
std::chrono::time_point< std::chrono::steady_clock > last_mouse_edge_scroll
Definition: game.h:1116
quit_status uquit
Used in main.cpp to determine what type of quit is being performed.
Definition: game.h:1026
event_bus & events()
Definition: game.cpp:3091
pimpl< stats_tracker > stats_tracker_ptr
Definition: game.h:1002
character_id next_npc_id
Definition: game.h:1084
pimpl< kill_tracker > kill_tracker_ptr
Definition: game.h:1004
void reset_light_level()
Definition: game.cpp:3935
pimpl< memorial_logger > memorial_logger_ptr
Definition: game.h:1005
shared_ptr_fast< player > u_shared_ptr
Definition: game.h:1073
pimpl< map > map_ptr
Definition: game.h:995
bool first_redraw_since_waiting_started
Is this the first redraw since waiting (sleeping or activity) started.
Definition: game.h:1099
pimpl< live_view > liveview_ptr
Definition: game.h:997
pimpl< achievements_tracker > achievements_tracker_ptr
Definition: game.h:1003
pimpl< scent_map > scent_ptr
Definition: game.h:999
timed_event_manager & timed_events
Definition: game.h:1014
unsigned int seed
Seed for all the random numbers that should have consistent randomness (weather).
Definition: game.h:1111
int next_mission_id
Definition: game.h:1086
bool new_game
True if the game has just started or loaded, else false.
Definition: game.h:1028
pimpl< distribution_grid_tracker > grid_tracker_ptr
Definition: game.h:1007
map & m
Definition: game.h:1011
avatar & u
Definition: game.h:1012
scent_map & scent
Definition: game.h:1013
int user_action_counter
Definition: game.h:1105
live_view & liveview
Definition: game.h:998
int tileset_zoom
How far the tileset should be zoomed out, 16 is default.
Definition: game.h:1108
pimpl< avatar > u_ptr
Definition: game.h:996
time_point remoteveh_cache_time
Definition: game.h:1092
static void achievement_attained(const achievement *a)
Definition: game.cpp:279
static constexpr int DEFAULT_TILESET_ZOOM
Definition: game.h:41
@ SAFE_MODE_ON
Definition: game.h:78
@ QUIT_NO
Definition: game.h:68
mapbuffer MAPBUFFER
Definition: mapbuffer.cpp:40
const time_point before_time_starts
A time point that is always before the current turn, even when the game has just started.
Definition: calendar.cpp:25
For use with smart pointers when you don't actually want the deleter to do anything.
Definition: cata_utility.h:28
std::unique_ptr< worldfactory > world_generator

References achievements_tracker_ptr, events(), first_redraw_since_waiting_started, kill_tracker_ptr, memorial_logger_ptr, reset_light_level(), spell_events_ptr, stats_tracker_ptr, event_bus::subscribe(), and world_generator.

◆ ~game()

game::~game ( )
default

Member Function Documentation

◆ add_artifact_dreams()

void game::add_artifact_dreams ( )

Definition at line 12358 of file game.cpp.

12359{
12360 //If player is sleeping, get a dream from a carried artifact
12361 //Don't need to check that player is sleeping here, that's done before calling
12362 std::list<item *> art_items = g->u.get_artifact_items();
12363 std::vector<item *> valid_arts;
12364 std::vector<std::vector<std::string>>
12365 valid_dreams; // Tracking separately so we only need to check its req once
12366 //Pull the list of dreams
12367 add_msg( m_debug, "Checking %s carried artifacts", art_items.size() );
12368 for( auto &it : art_items ) {
12369 //Pick only the ones with an applicable dream
12370 const cata::value_ptr<islot_artifact> &art = it->type->artifact;
12371 if( art && art->charge_req != ACR_NULL &&
12372 ( it->ammo_remaining() < it->ammo_capacity() ||
12373 it->ammo_capacity() == 0 ) ) { //or max 0 in case of wacky mod shenanigans
12374 add_msg( m_debug, "Checking artifact %s", it->tname() );
12375 if( check_art_charge_req( *it ) ) {
12376 add_msg( m_debug, " Has freq %s,%s", art->dream_freq_met, art->dream_freq_unmet );
12377 if( art->dream_freq_met > 0 && x_in_y( art->dream_freq_met, 100 ) ) {
12378 add_msg( m_debug, "Adding met dream from %s", it->tname() );
12379 valid_arts.push_back( it );
12380 valid_dreams.push_back( art->dream_msg_met );
12381 }
12382 } else {
12383 add_msg( m_debug, " Has freq %s,%s", art->dream_freq_met, art->dream_freq_unmet );
12384 if( art->dream_freq_unmet > 0 && x_in_y( art->dream_freq_unmet, 100 ) ) {
12385 add_msg( m_debug, "Adding unmet dream from %s", it->tname() );
12386 valid_arts.push_back( it );
12387 valid_dreams.push_back( art->dream_msg_unmet );
12388 }
12389 }
12390 }
12391 }
12392 if( !valid_dreams.empty() ) {
12393 add_msg( m_debug, "Found %s valid artifact dreams", valid_dreams.size() );
12394 const int selected = rng( 0, valid_arts.size() - 1 );
12395 auto it = valid_arts[selected];
12396 auto msg = random_entry( valid_dreams[selected] );
12397 const std::string &dream = string_format( _( msg ), it->tname() );
12398 add_msg( dream );
12399 } else {
12400 add_msg( m_debug, "Didn't have any dreams, sorry" );
12401 }
12402}
units::quantity< V, B > rng(const units::quantity< V, B > &min, const units::quantity< V, B > &max)
Definition: artifact.cpp:32
@ ACR_NULL
Definition: artifact.h:79
bool x_in_y(const time_duration &a, const time_duration &b)
Definition: calendar.cpp:521
This class is essentially a copyable unique pointer.
Definition: value_ptr.h:19
@ m_debug
Definition: enums.h:264
std::unique_ptr< game > g
Definition: game.cpp:269
bool check_art_charge_req(item &it)
Definition: game.cpp:12061
void add_msg(std::string msg)
Definition: messages.cpp:884
V random_entry(const C &container, D default_value)
Returns a random entry in the container.
Definition: rng.h:88
std::string string_format(std::string format, Args &&...args)
Simple wrapper over string_formatter::parse.
#define _(msg)
Definition: translations.h:116

References _, ACR_NULL, add_msg(), check_art_charge_req(), g, m_debug, random_entry(), rng(), string_format(), and x_in_y().

Referenced by do_turn().

◆ add_artifact_messages()

void game::add_artifact_messages ( const std::vector< art_effect_passive > &  effects)

Definition at line 12180 of file game.cpp.

12181{
12182 int net_str = 0;
12183 int net_dex = 0;
12184 int net_per = 0;
12185 int net_int = 0;
12186 int net_speed = 0;
12187
12188 for( auto &i : effects ) {
12189 switch( i ) {
12190 case AEP_STR_UP:
12191 net_str += 4;
12192 break;
12193 case AEP_DEX_UP:
12194 net_dex += 4;
12195 break;
12196 case AEP_PER_UP:
12197 net_per += 4;
12198 break;
12199 case AEP_INT_UP:
12200 net_int += 4;
12201 break;
12202 case AEP_ALL_UP:
12203 net_str += 2;
12204 net_dex += 2;
12205 net_per += 2;
12206 net_int += 2;
12207 break;
12208 case AEP_STR_DOWN:
12209 net_str -= 3;
12210 break;
12211 case AEP_DEX_DOWN:
12212 net_dex -= 3;
12213 break;
12214 case AEP_PER_DOWN:
12215 net_per -= 3;
12216 break;
12217 case AEP_INT_DOWN:
12218 net_int -= 3;
12219 break;
12220 case AEP_ALL_DOWN:
12221 net_str -= 2;
12222 net_dex -= 2;
12223 net_per -= 2;
12224 net_int -= 2;
12225 break;
12226
12227 case AEP_SPEED_UP:
12228 net_speed += 20;
12229 break;
12230 case AEP_SPEED_DOWN:
12231 net_speed -= 20;
12232 break;
12233
12234 case AEP_PBLUE:
12235 break; // No message
12236
12237 case AEP_SNAKES:
12238 add_msg( m_warning, _( "Your skin feels slithery." ) );
12239 break;
12240
12241 case AEP_INVISIBLE:
12242 add_msg( m_good, _( "You fade into invisibility!" ) );
12243 break;
12244
12245 case AEP_CLAIRVOYANCE:
12247 add_msg( m_good, _( "You can see through walls!" ) );
12248 break;
12249
12251 add_msg( m_good, _( "You can see through everything!" ) );
12252 break;
12253
12254 case AEP_STEALTH:
12255 add_msg( m_good, _( "Your steps stop making noise." ) );
12256 break;
12257
12258 case AEP_GLOW:
12259 add_msg( _( "A glow of light forms around you." ) );
12260 break;
12261
12262 case AEP_PSYSHIELD:
12263 add_msg( m_good, _( "Your mental state feels protected." ) );
12264 break;
12265
12267 add_msg( m_good, _( "You feel insulated." ) );
12268 break;
12269
12270 case AEP_CARRY_MORE:
12271 add_msg( m_good, _( "Your back feels strengthened." ) );
12272 break;
12273
12274 case AEP_FUN:
12275 add_msg( m_good, _( "You feel a pleasant tingle." ) );
12276 break;
12277
12278 case AEP_HUNGER:
12279 add_msg( m_warning, _( "You feel hungry." ) );
12280 break;
12281
12282 case AEP_THIRST:
12283 add_msg( m_warning, _( "You feel thirsty." ) );
12284 break;
12285
12286 case AEP_EVIL:
12287 add_msg( m_warning, _( "You feel an evil presence…" ) );
12288 break;
12289
12290 case AEP_SCHIZO:
12291 add_msg( m_bad, _( "You feel a tickle of insanity." ) );
12292 break;
12293
12294 case AEP_RADIOACTIVE:
12295 add_msg( m_warning, _( "Your skin prickles with radiation." ) );
12296 break;
12297
12298 case AEP_MUTAGENIC:
12299 add_msg( m_bad, _( "You feel your genetic makeup degrading." ) );
12300 break;
12301
12302 case AEP_ATTENTION:
12303 add_msg( m_warning, _( "You feel an otherworldly attention upon you…" ) );
12304 break;
12305
12306 case AEP_FORCE_TELEPORT:
12307 add_msg( m_bad, _( "You feel a force pulling you inwards." ) );
12308 break;
12309
12310 case AEP_MOVEMENT_NOISE:
12311 add_msg( m_warning, _( "You hear a rattling noise coming from inside yourself." ) );
12312 break;
12313
12314 case AEP_BAD_WEATHER:
12315 add_msg( m_warning, _( "You feel storms coming." ) );
12316 break;
12317
12318 case AEP_SICK:
12319 add_msg( m_bad, _( "You feel unwell." ) );
12320 break;
12321
12322 case AEP_SMOKE:
12323 add_msg( m_warning, _( "A cloud of smoke appears." ) );
12324 break;
12325 default:
12326 //Suppress warnings
12327 break;
12328 }
12329 }
12330
12331 std::string stat_info;
12332 if( net_str != 0 ) {
12333 stat_info += string_format( _( "Str %s%d! " ),
12334 ( net_str > 0 ? "+" : "" ), net_str );
12335 }
12336 if( net_dex != 0 ) {
12337 stat_info += string_format( _( "Dex %s%d! " ),
12338 ( net_dex > 0 ? "+" : "" ), net_dex );
12339 }
12340 if( net_int != 0 ) {
12341 stat_info += string_format( _( "Int %s%d! " ),
12342 ( net_int > 0 ? "+" : "" ), net_int );
12343 }
12344 if( net_per != 0 ) {
12345 stat_info += string_format( _( "Per %s%d! " ),
12346 ( net_per > 0 ? "+" : "" ), net_per );
12347 }
12348
12349 if( !stat_info.empty() ) {
12350 add_msg( m_neutral, stat_info );
12351 }
12352
12353 if( net_speed != 0 ) {
12354 add_msg( m_info, _( "Speed %s%d!" ), ( net_speed > 0 ? "+" : "" ), net_speed );
12355 }
12356}
@ m_good
Definition: enums.h:253
@ m_neutral
Definition: enums.h:260
@ m_info
Definition: enums.h:258
@ m_bad
Definition: enums.h:254
@ m_warning
Definition: enums.h:257
@ AEP_GLOW
Definition: enums.h:115
@ AEP_MUTAGENIC
Definition: enums.h:130
@ AEP_ALL_UP
Definition: enums.h:106
@ AEP_INT_UP
Definition: enums.h:105
@ AEP_INT_DOWN
Definition: enums.h:135
@ AEP_PER_UP
Definition: enums.h:104
@ AEP_PSYSHIELD
Definition: enums.h:116
@ AEP_CLAIRVOYANCE_PLUS
Definition: enums.h:142
@ AEP_MOVEMENT_NOISE
Definition: enums.h:139
@ AEP_STEALTH
Definition: enums.h:113
@ AEP_CARRY_MORE
Definition: enums.h:118
@ AEP_THIRST
Definition: enums.h:125
@ AEP_SPEED_UP
Definition: enums.h:107
@ AEP_EVIL
Definition: enums.h:127
@ AEP_ALL_DOWN
Definition: enums.h:136
@ AEP_DEX_UP
Definition: enums.h:103
@ AEP_SCHIZO
Definition: enums.h:128
@ AEP_DEX_DOWN
Definition: enums.h:133
@ AEP_FUN
Definition: enums.h:120
@ AEP_PER_DOWN
Definition: enums.h:134
@ AEP_FORCE_TELEPORT
Definition: enums.h:138
@ AEP_ATTENTION
Definition: enums.h:131
@ AEP_RADIOACTIVE
Definition: enums.h:129
@ AEP_SUPER_CLAIRVOYANCE
Definition: enums.h:112
@ AEP_BAD_WEATHER
Definition: enums.h:140
@ AEP_SICK
Definition: enums.h:141
@ AEP_CLAIRVOYANCE
Definition: enums.h:111
@ AEP_INVISIBLE
Definition: enums.h:110
@ AEP_STR_UP
Definition: enums.h:102
@ AEP_STR_DOWN
Definition: enums.h:132
@ AEP_HUNGER
Definition: enums.h:124
@ AEP_RESIST_ELECTRICITY
Definition: enums.h:117
@ AEP_PBLUE
Definition: enums.h:108
@ AEP_SPEED_DOWN
Definition: enums.h:137
@ AEP_SNAKES
Definition: enums.h:109
@ AEP_SMOKE
Definition: enums.h:126

References _, add_msg(), AEP_ALL_DOWN, AEP_ALL_UP, AEP_ATTENTION, AEP_BAD_WEATHER, AEP_CARRY_MORE, AEP_CLAIRVOYANCE, AEP_CLAIRVOYANCE_PLUS, AEP_DEX_DOWN, AEP_DEX_UP, AEP_EVIL, AEP_FORCE_TELEPORT, AEP_FUN, AEP_GLOW, AEP_HUNGER, AEP_INT_DOWN, AEP_INT_UP, AEP_INVISIBLE, AEP_MOVEMENT_NOISE, AEP_MUTAGENIC, AEP_PBLUE, AEP_PER_DOWN, AEP_PER_UP, AEP_PSYSHIELD, AEP_RADIOACTIVE, AEP_RESIST_ELECTRICITY, AEP_SCHIZO, AEP_SICK, AEP_SMOKE, AEP_SNAKES, AEP_SPEED_DOWN, AEP_SPEED_UP, AEP_STEALTH, AEP_STR_DOWN, AEP_STR_UP, AEP_SUPER_CLAIRVOYANCE, AEP_THIRST, m_bad, m_good, m_info, m_neutral, m_warning, and string_format().

◆ add_draw_callback()

void game::add_draw_callback ( shared_ptr_fast< draw_callback_t cb)

Definition at line 3386 of file game.cpp.

3387{
3388 draw_callbacks.erase(
3389 std::remove_if( draw_callbacks.begin(), draw_callbacks.end(),
3390 []( const weak_ptr_fast<draw_callback_t> &cbw ) {
3391 return cbw.expired();
3392 } ),
3393 draw_callbacks.end()
3394 );
3395 draw_callbacks.emplace_back( cb );
3396 cb->added = true;
3398}
void invalidate_main_ui_adaptor() const
Definition: game.cpp:3351
std::vector< weak_ptr_fast< draw_callback_t > > draw_callbacks
Definition: game.h:251
std::weak_ptr< T > weak_ptr_fast
Definition: memory_fast.h:17

References draw_callbacks, and invalidate_main_ui_adaptor().

Referenced by get_player_input(), list_items(), list_monsters(), look_around(), pickup(), and zones_manager().

◆ add_npc_follower()

void game::add_npc_follower ( const character_id id)

Add follower id to set of followers.

Definition at line 1960 of file game.cpp.

1961{
1962 follower_ids.insert( id );
1963 u.follower_ids.insert( id );
1964}
std::set< character_id > follower_ids
Definition: game.h:1087
std::set< character_id > follower_ids
Definition: player.h:667

References follower_ids, player::follower_ids, and u.

Referenced by validate_npc_followers().

◆ all_creatures()

game::Creature_range game::all_creatures ( )

Returns an anonymous range that contains all creatures.

The range allows iteration via a range-based for loop, e.g. for( Creature &critter : all_creatures() ) { ... }. One shall not store the returned range nor the iterators. One can freely remove and add creatures to the game during the iteration. Added creatures will not be iterated over.

Definition at line 12514 of file game.cpp.

12515{
12516 return Creature_range( *this );
12517}
friend class Creature_range
Definition: game.h:360

References Creature_range.

Referenced by draw_ter(), get_creature_if(), and get_creatures_if().

◆ all_monsters()

game::monster_range game::all_monsters ( )

Same as all_creatures but iterators only over monsters.

Definition at line 12519 of file game.cpp.

12520{
12521 return monster_range( *this );
12522}
friend class monster_range
Definition: game.h:359

References monster_range.

Referenced by cleanup_at_end(), disp_NPCs(), get_fishable_monsters(), monmove(), place_player_overmap(), shift_monsters(), start_game(), validate_mounted_npcs(), and vertical_move().

◆ all_npcs()

game::npc_range game::all_npcs ( )

Same as all_creatures but iterators only over npcs.

Definition at line 12524 of file game.cpp.

12525{
12526 return npc_range( *this );
12527}

Referenced by do_turn(), and get_npcs_if().

◆ allies()

std::vector< npc * > game::allies ( )

Get all living player allies.

Definition at line 12428 of file game.cpp.

12429{
12430 return get_npcs_if( [&]( const npc & guy ) {
12431 if( !guy.is_hallucination() ) {
12432 return guy.is_ally( g->u );
12433 } else {
12434 return false;
12435 }
12436 } );
12437}
std::vector< npc * > get_npcs_if(const std::function< bool(const npc &)> &pred)
Definition: game.cpp:12451
Definition: npc.h:781
bool is_hallucination() const override
Definition: npc.cpp:3257

References get_npcs_if(), and npc::is_hallucination().

◆ assign_mission_id()

int game::assign_mission_id ( )

Returns the next available mission id.

Definition at line 1948 of file game.cpp.

1949{
1950 int ret = next_mission_id;
1952 return ret;
1953}

References next_mission_id, and cata::hash64_detail::ret.

◆ assign_npc_id()

character_id game::assign_npc_id ( )

Definition at line 3943 of file game.cpp.

3944{
3946 ++next_npc_id;
3947 return ret;
3948}

References next_npc_id, and cata::hash64_detail::ret.

Referenced by load(), and start_game().

◆ autopilot_vehicles()

void game::autopilot_vehicles ( )

process vehicles that are following the player

Definition at line 1753 of file game.cpp.

1754{
1755 for( wrapped_vehicle &veh : m.get_vehicles() ) {
1756 vehicle *&v = veh.v;
1757 if( v->is_following ) {
1758 v->drive_to_local_target( m.getabs( u.pos() ), true );
1759 } else if( v->is_patrolling ) {
1760 v->autopilot_patrol();
1761 }
1762 }
1763}
const tripoint & pos() const override
Definition: character.cpp:714
tripoint getabs(const tripoint &p) const
Translates local (to this map) coordinates of a square to global absolute coordinates.
Definition: map.cpp:8074
VehicleList get_vehicles()
Definition: map.cpp:233
A vehicle as a whole with all its components.
Definition: vehicle.h:675
void autopilot_patrol()
Definition: vehicle.cpp:701
bool is_following
Definition: vehicle.h:1963
bool is_patrolling
Definition: vehicle.h:1964
void drive_to_local_target(const tripoint &target, bool follow_protocol)
Definition: vehicle.cpp:816

References vehicle::autopilot_patrol(), vehicle::drive_to_local_target(), map::get_vehicles(), map::getabs(), vehicle::is_following, vehicle::is_patrolling, m, Character::pos(), and u.

Referenced by do_turn().

◆ autosave()

void game::autosave ( )
private

Definition at line 11847 of file game.cpp.

11848{
11849 //Don't autosave if the min-autosave interval has not passed since the last autosave/quicksave.
11850 if( time( nullptr ) < last_save_timestamp + 60 * get_option<int>( "AUTOSAVE_MINUTES" ) ) {
11851 return;
11852 }
11853 quicksave(); //Driving checks are handled by quicksave()
11854}
time_t last_save_timestamp
Definition: game.h:1089
void quicksave()
Definition: game.cpp:11802

References last_save_timestamp, and quicksave().

Referenced by do_turn().

◆ butcher()

void game::butcher ( )
private

Definition at line 8571 of file game.cpp.

8572{
8573 static const std::string salvage_string = "salvage";
8574 if( u.controlling_vehicle ) {
8575 add_msg( m_info, _( "You can't butcher while driving!" ) );
8576 return;
8577 }
8578
8579 const int factor = u.max_quality( quality_id( "BUTCHER" ) );
8580 const int factorD = u.max_quality( quality_id( "CUT_FINE" ) );
8581 const std::string no_knife_msg = _( "You don't have a butchering tool." );
8582 const std::string no_corpse_msg = _( "There are no corpses here to butcher." );
8583
8584 //You can't butcher on sealed terrain- you have to smash/shovel/etc it open first
8585 if( m.has_flag( "SEALED", u.pos() ) ) {
8586 if( m.sees_some_items( u.pos(), u ) ) {
8587 add_msg( m_info, _( "You can't access the items here." ) );
8588 } else if( factor > INT_MIN || factorD > INT_MIN ) {
8589 add_msg( m_info, no_corpse_msg );
8590 } else {
8591 add_msg( m_info, no_knife_msg );
8592 }
8593 return;
8594 }
8595
8596 const item *first_item_without_tools = nullptr;
8597 // Indices of relevant items
8598 std::vector<map_stack::iterator> corpses;
8599 std::vector<map_stack::iterator> disassembles;
8600 std::vector<map_stack::iterator> salvageables;
8601 map_stack items = m.i_at( u.pos() );
8602 const inventory &crafting_inv = u.crafting_inventory();
8603
8604 // TODO: Properly handle different material whitelists
8605 // TODO: Improve quality of this section
8606 auto salvage_filter = []( item it ) {
8607 const auto usable = it.get_usable_item( salvage_string );
8608 return usable != nullptr;
8609 };
8610
8611 std::vector< item * > salvage_tools = u.items_with( salvage_filter );
8612 int salvage_tool_index = INT_MIN;
8613 item *salvage_tool = nullptr;
8614 const salvage_actor *salvage_iuse = nullptr;
8615 if( !salvage_tools.empty() ) {
8616 salvage_tool = salvage_tools.front();
8617 salvage_tool_index = u.get_item_position( salvage_tool );
8618 item *usable = salvage_tool->get_usable_item( salvage_string );
8619 salvage_iuse = dynamic_cast<const salvage_actor *>(
8620 usable->get_use( salvage_string )->get_actor_ptr() );
8621 }
8622
8623 // Reserve capacity for each to hold entire item set if necessary to prevent
8624 // reallocations later on
8625 corpses.reserve( items.size() );
8626 salvageables.reserve( items.size() );
8627 disassembles.reserve( items.size() );
8628
8629 // Split into corpses, disassemble-able, and salvageable items
8630 // It's not much additional work to just generate a corpse list and
8631 // clear it later, but does make the splitting process nicer.
8632 for( map_stack::iterator it = items.begin(); it != items.end(); ++it ) {
8633 if( it->is_corpse() ) {
8634 corpses.push_back( it );
8635 } else {
8636 if( ( salvage_tool_index != INT_MIN ) && salvage_iuse->valid_to_cut_up( *it ) ) {
8637 salvageables.push_back( it );
8638 }
8639 if( u.can_disassemble( *it, crafting_inv ).success() ) {
8640 disassembles.push_back( it );
8641 } else if( !first_item_without_tools ) {
8642 first_item_without_tools = &*it;
8643 }
8644 }
8645 }
8646
8647 // Clear corpses if butcher and dissect factors are INT_MIN
8648 if( factor == INT_MIN && factorD == INT_MIN ) {
8649 corpses.clear();
8650 }
8651
8652 if( corpses.empty() && disassembles.empty() && salvageables.empty() ) {
8653 if( factor > INT_MIN || factorD > INT_MIN ) {
8654 add_msg( m_info, no_corpse_msg );
8655 } else {
8656 add_msg( m_info, no_knife_msg );
8657 }
8658
8659 if( first_item_without_tools ) {
8660 add_msg( m_info, _( "You don't have the necessary tools to disassemble any items here." ) );
8661 // Just for the "You need x to disassemble y" messages
8662 const auto ret = u.can_disassemble( *first_item_without_tools, crafting_inv );
8663 if( !ret.success() ) {
8664 add_msg( m_info, "%s", ret.c_str() );
8665 }
8666 }
8667 return;
8668 }
8669
8670 Creature *hostile_critter = is_hostile_very_close();
8671 if( hostile_critter != nullptr ) {
8672 if( !query_yn( _( "You see %s nearby! Start butchering anyway?" ),
8673 hostile_critter->disp_name() ) ) {
8674 return;
8675 }
8676 }
8677
8678 // Magic indices for special butcher options
8679 enum : int {
8680 MULTISALVAGE = MAX_ITEM_IN_SQUARE + 1,
8681 MULTIBUTCHER,
8682 MULTIDISASSEMBLE_ONE,
8683 MULTIDISASSEMBLE_ALL,
8684 NUM_BUTCHER_ACTIONS
8685 };
8686 // What are we butchering (i.e.. which vector to pick indices from)
8687 enum {
8688 BUTCHER_CORPSE,
8689 BUTCHER_DISASSEMBLE,
8690 BUTCHER_SALVAGE,
8691 BUTCHER_OTHER // For multisalvage etc.
8692 } butcher_select = BUTCHER_CORPSE;
8693 // Index to std::vector of iterators...
8694 int indexer_index = 0;
8695
8696 // Generate the indexed stacks so we can display them nicely
8697 const auto disassembly_stacks = generate_butcher_stack_display( disassembles );
8698 const auto salvage_stacks = generate_butcher_stack_display( salvageables );
8699 // Always ask before cutting up/disassembly, but not before butchery
8700 size_t ret = 0;
8701 if( !corpses.empty() || !disassembles.empty() || !salvageables.empty() ) {
8702 uilist kmenu;
8703 kmenu.text = _( "Choose corpse to butcher / item to disassemble" );
8704
8705 size_t i = 0;
8706 // Add corpses, disassembleables, and salvagables to the UI
8707 add_corpses( kmenu, corpses, i );
8708 add_disassemblables( kmenu, disassembly_stacks, i );
8709 if( salvage_iuse && !salvageables.empty() ) {
8710 add_salvagables( kmenu, salvage_stacks, i, *salvage_iuse );
8711 }
8712
8713 if( corpses.size() > 1 ) {
8714 kmenu.addentry( MULTIBUTCHER, true, 'b', _( "Butcher everything" ) );
8715 }
8716 if( disassembles.size() > 1 ) {
8717 int time_to_disassemble = 0;
8718 int time_to_disassemble_all = 0;
8719 for( const auto &stack : disassembly_stacks ) {
8720 const int time = recipe_dictionary::get_uncraft( stack.first->typeId() ).time;
8721 time_to_disassemble += time;
8722 time_to_disassemble_all += time * stack.second;
8723 }
8724
8725 kmenu.addentry_col( MULTIDISASSEMBLE_ONE, true, 'D', _( "Disassemble everything once" ),
8726 to_string_clipped( time_duration::from_turns( time_to_disassemble / 100 ) ) );
8727 kmenu.addentry_col( MULTIDISASSEMBLE_ALL, true, 'd', _( "Disassemble everything recursively" ),
8728 to_string_clipped( time_duration::from_turns( time_to_disassemble_all / 100 ) ) );
8729 }
8730 if( salvage_iuse && salvageables.size() > 1 ) {
8731 int time_to_salvage = 0;
8732 for( const auto &stack : salvage_stacks ) {
8733 time_to_salvage += salvage_iuse->time_to_cut_up( *stack.first ) * stack.second;
8734 }
8735
8736 kmenu.addentry_col( MULTISALVAGE, true, 'z', _( "Cut up everything" ),
8737 to_string_clipped( time_duration::from_turns( time_to_salvage / 100 ) ) );
8738 }
8739
8740 kmenu.query();
8741
8742 if( kmenu.ret < 0 || kmenu.ret >= NUM_BUTCHER_ACTIONS ) {
8743 return;
8744 }
8745
8746 ret = static_cast<size_t>( kmenu.ret );
8747 if( ret >= MULTISALVAGE && ret < NUM_BUTCHER_ACTIONS ) {
8748 butcher_select = BUTCHER_OTHER;
8749 indexer_index = ret;
8750 } else if( ret < corpses.size() ) {
8751 butcher_select = BUTCHER_CORPSE;
8752 indexer_index = ret;
8753 } else if( ret < corpses.size() + disassembly_stacks.size() ) {
8754 butcher_select = BUTCHER_DISASSEMBLE;
8755 indexer_index = ret - corpses.size();
8756 } else if( ret < corpses.size() + disassembly_stacks.size() + salvage_stacks.size() ) {
8757 butcher_select = BUTCHER_SALVAGE;
8758 indexer_index = ret - corpses.size() - disassembly_stacks.size();
8759 } else {
8760 debugmsg( "Invalid butchery index: %d", ret );
8761 return;
8762 }
8763 }
8764
8765 if( !u.has_morale_to_craft() ) {
8766 if( butcher_select == BUTCHER_CORPSE || indexer_index == MULTIBUTCHER ) {
8767 add_msg( m_info,
8768 _( "You are not in the mood and the prospect of guts and blood on your hands convinces you to turn away." ) );
8769 } else {
8770 add_msg( m_info,
8771 _( "You are not in the mood and the prospect of work stops you before you begin." ) );
8772 }
8773 return;
8774 }
8775 const auto helpers = u.get_crafting_helpers( 3 );
8776 for( const npc *np : helpers ) {
8777 add_msg( m_info, _( "%s helps with this task…" ), np->name );
8778 }
8779 switch( butcher_select ) {
8780 case BUTCHER_OTHER:
8781 switch( indexer_index ) {
8782 case MULTISALVAGE:
8783 u.assign_activity( activity_id( "ACT_LONGSALVAGE" ), 0, salvage_tool_index );
8784 break;
8785 case MULTIBUTCHER:
8786 butcher_submenu( corpses );
8787 for( map_stack::iterator &it : corpses ) {
8788 u.activity.targets.emplace_back( map_cursor( u.pos() ), &*it );
8789 }
8790 break;
8791 case MULTIDISASSEMBLE_ONE:
8792 u.disassemble_all( true );
8793 break;
8794 case MULTIDISASSEMBLE_ALL:
8795 u.disassemble_all( false );
8796 break;
8797 default:
8798 debugmsg( "Invalid butchery type: %d", indexer_index );
8799 return;
8800 }
8801 break;
8802 case BUTCHER_CORPSE: {
8803 butcher_submenu( corpses, indexer_index );
8804 u.activity.targets.emplace_back( map_cursor( u.pos() ), &*corpses[indexer_index] );
8805 }
8806 break;
8807 case BUTCHER_DISASSEMBLE: {
8808 // Pick index of first item in the disassembly stack
8809 item *const target = &*disassembly_stacks[indexer_index].first;
8810 u.disassemble( item_location( map_cursor( u.pos() ), target ), true );
8811 }
8812 break;
8813 case BUTCHER_SALVAGE: {
8814 if( !salvage_iuse || !salvage_tool ) {
8815 debugmsg( "null salve_iuse or salvage_tool" );
8816 } else {
8817 // Pick index of first item in the salvage stack
8818 item *const target = &*salvage_stacks[indexer_index].first;
8819 item_location item_loc( map_cursor( u.pos() ), target );
8820 salvage_iuse->cut_up( u, *salvage_tool, item_loc );
8821 }
8822 }
8823 break;
8824 }
8825}
string_id< activity_type > activity_id
Definition: activity_type.h:15
static std::string to_string_clipped(const int num, const clipped_unit type, const clipped_align align)
Definition: calendar.cpp:228
bool controlling_vehicle
Definition: character.h:227
player_activity activity
Definition: character.h:1524
int get_item_position(const item *it) const
Returns the item position (suitable for i_at or similar) of a specific item.
Definition: character.cpp:2410
bool has_morale_to_craft() const
Definition: crafting.cpp:330
const inventory & crafting_inventory(bool clear_path)
Definition: crafting.cpp:548
void assign_activity(const activity_id &type, int moves=calendar::INDEFINITELY_LONG, int index=-1, int pos=INT_MIN, const std::string &name="")
Legacy activity assignment, does not work for any activites using the new activity_actor class and ma...
Definition: character.cpp:9203
virtual std::string disp_name(bool possessive=false, bool capitalize_first=false) const =0
Creature * is_hostile_very_close()
Definition: game.cpp:3957
A lightweight handle to an item independent of it's location Unlike a raw pointer can be (de-)seriali...
Definition: item_location.h:23
size_t size() const
Definition: item_stack.cpp:10
iterator begin()
Definition: item_stack.cpp:28
iterator end()
Definition: item_stack.cpp:33
Definition: item.h:176
item * get_usable_item(const std::string &use_name)
Checks this item and its contents (recursively) for types that have use_function with type use_name.
Definition: item.cpp:7806
const use_function * get_use(const std::string &use_name) const
Returns the pointer to use_function with name use_name assigned to the type of this item or any of it...
Definition: item.cpp:7780
Definition: map.h:101
bool has_flag(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2288
map_stack i_at(const tripoint &p)
Definition: map.cpp:4069
bool sees_some_items(const tripoint &p, const Creature &who) const
Check if creature can see some items at p.
Definition: map.cpp:4715
std::vector< item_location > targets
void disassemble_all(bool one_pass)
Definition: crafting.cpp:2034
std::vector< npc * > get_crafting_helpers(size_t max=0) const
Returns nearby NPCs ready and willing to help with crafting or some other manual task.
Definition: crafting.cpp:2326
ret_val< bool > can_disassemble(const item &obj, const inventory &inv) const
Check if the player can disassemble an item using the current crafting inventory.
Definition: crafting.cpp:1859
bool disassemble()
Definition: crafting.cpp:1932
static const recipe & get_uncraft(const itype_id &id)
Returns disassembly recipe (or null recipe if no match)
int time
Definition: recipe.h:59
Cuts stuff up into components.
Definition: iuse_actor.h:567
bool valid_to_cut_up(const item &it) const
int cut_up(player &p, item &it, item_location &cut) const
int time_to_cut_up(const item &it) const
static constexpr time_duration from_turns(const T t)
Named constructors to get a duration representing a multiple of the named time units.
Definition: calendar.h:204
uilist: scrolling vertical list menu
Definition: ui.h:187
int ret
Definition: ui.h:412
void addentry_col(int r, bool e, int k, const std::string &str, const std::string &column, const std::string &desc="")
Definition: ui.cpp:952
std::string text
Definition: ui.h:320
void addentry(const std::string &str)
Definition: ui.cpp:932
int max_quality(const quality_id &qual) const
Return maximum tool quality level provided by instance or INT_MIN if not found.
Definition: visitable.cpp:276
std::vector< item * > items_with(const std::function< bool(const item &)> &filter)
Returns all items (including those within a container) matching the filter.
Definition: visitable.cpp:324
#define debugmsg(...)
Debug message of level DL::Error and class DC::DebugMsg, also includes the source file name and line,...
Definition: debug.h:74
static void butcher_submenu(const std::vector< map_stack::iterator > &corpses, int corpse=-1)
Definition: game.cpp:8422
static void add_salvagables(uilist &menu, const std::vector< std::pair< map_stack::iterator, int > > &stacks, size_t &menu_index, const salvage_actor &salvage_iuse)
Definition: game.cpp:8380
static void add_disassemblables(uilist &menu, const std::vector< std::pair< map_stack::iterator, int > > &stacks, size_t &menu_index)
Definition: game.cpp:8401
static std::vector< std::pair< map_stack::iterator, int > > generate_butcher_stack_display(const std::vector< map_stack::iterator > &its)
Definition: game.cpp:8333
static void add_corpses(uilist &menu, const std::vector< map_stack::iterator > &its, size_t &menu_index)
Definition: game.cpp:8368
static constexpr int MAX_ITEM_IN_SQUARE
void query(bool loop=true, int timeout=-1)
Handle input and update display.
Definition: ui.cpp:828
bool query_yn(const std::string &text)
Definition: output.cpp:698
iuse_actor * get_actor_ptr()
Definition: iuse.h:315
string_id< quality > quality_id
Definition: type_id.h:174

References _, Character::activity, add_corpses(), add_disassemblables(), add_msg(), add_salvagables(), uilist::addentry(), uilist::addentry_col(), Character::assign_activity(), item_stack::begin(), butcher_submenu(), player::can_disassemble(), Character::controlling_vehicle, Character::crafting_inventory(), salvage_actor::cut_up(), debugmsg, player::disassemble(), player::disassemble_all(), Creature::disp_name(), item_stack::end(), time_duration::from_turns(), generate_butcher_stack_display(), use_function::get_actor_ptr(), player::get_crafting_helpers(), Character::get_item_position(), recipe_dictionary::get_uncraft(), item::get_usable_item(), item::get_use(), map::has_flag(), Character::has_morale_to_craft(), map::i_at(), is_hostile_very_close(), visitable< T >::items_with(), m, m_info, MAX_ITEM_IN_SQUARE, visitable< T >::max_quality(), Character::pos(), uilist::query(), query_yn(), cata::hash64_detail::ret, uilist::ret, map::sees_some_items(), item_stack::size(), player_activity::targets, uilist::text, recipe::time, salvage_actor::time_to_cut_up(), to_string_clipped(), u, and salvage_actor::valid_to_cut_up().

Referenced by handle_action().

◆ calc_driving_offset()

void game::calc_driving_offset ( vehicle veh = nullptr)

Definition at line 1334 of file game.cpp.

1335{
1336 if( veh == nullptr || !get_option<bool>( "DRIVING_VIEW_OFFSET" ) ) {
1338 return;
1339 }
1340 const int g_light_level = static_cast<int>( light_level( u.posz() ) );
1341 const int light_sight_range = u.sight_range( g_light_level );
1342 int sight = std::max( veh_lumi( *veh ), light_sight_range );
1343
1344 // The maximal offset will leave at least this many tiles
1345 // between the PC and the edge of the main window.
1346 static const int border_range = 2;
1347 point max_offset( ( getmaxx( w_terrain ) + 1 ) / 2 - border_range - 1,
1348 ( getmaxy( w_terrain ) + 1 ) / 2 - border_range - 1 );
1349
1350 // velocity at or below this results in no offset at all
1351 static const float min_offset_vel = 1 * vehicles::vmiph_per_tile;
1352 // velocity at or above this results in maximal offset
1353 static const float max_offset_vel = std::min( max_offset.y, max_offset.x ) *
1355 float velocity = veh->velocity;
1356 rl_vec2d offset = veh->move_vec();
1357 if( !veh->skidding && veh->player_in_control( u ) &&
1358 std::abs( veh->cruise_velocity - veh->velocity ) < 7 * vehicles::vmiph_per_tile ) {
1359 // Use the cruise controlled velocity, but only if
1360 // it is not too different from the actual velocity.
1361 // The actual velocity changes too often (see above slowdown).
1362 // Using it makes would make the offset change far too often.
1363 offset = veh->face_vec();
1364 velocity = veh->cruise_velocity;
1365 }
1366 float rel_offset;
1367 if( std::fabs( velocity ) < min_offset_vel ) {
1368 rel_offset = 0;
1369 } else if( std::fabs( velocity ) > max_offset_vel ) {
1370 rel_offset = ( velocity > 0 ) ? 1 : -1;
1371 } else {
1372 rel_offset = ( velocity - min_offset_vel ) / ( max_offset_vel - min_offset_vel );
1373 }
1374 // Squeeze into the corners, by making the offset vector longer,
1375 // the PC is still in view as long as both offset.x and
1376 // offset.y are <= 1
1377 if( std::fabs( offset.x ) > std::fabs( offset.y ) && std::fabs( offset.x ) > 0.2 ) {
1378 offset.y /= std::fabs( offset.x );
1379 offset.x = ( offset.x > 0 ) ? +1 : -1;
1380 } else if( std::fabs( offset.y ) > 0.2 ) {
1381 offset.x /= std::fabs( offset.y );
1382 offset.y = offset.y > 0 ? +1 : -1;
1383 }
1384 offset.x *= rel_offset;
1385 offset.y *= rel_offset;
1386 offset.x *= max_offset.x;
1387 offset.y *= max_offset.y;
1388 // [ ----@---- ] sight=6
1389 // [ --@------ ] offset=2
1390 // [ -@------# ] offset=3
1391 // can see sights square in every direction, total visible area is
1392 // (2*sight+1)x(2*sight+1), but the window is only
1393 // getmaxx(w_terrain) x getmaxy(w_terrain)
1394 // The area outside of the window is maxoff (sight-getmax/2).
1395 // If that value is <= 0, the whole visible area fits the window.
1396 // don't apply the view offset at all.
1397 // If the offset is > maxoff, only apply at most maxoff, everything
1398 // above leads to invisible area in front of the car.
1399 // It will display (getmax/2+offset) squares in one direction and
1400 // (getmax/2-offset) in the opposite direction (centered on the PC).
1401 const point maxoff( ( sight * 2 + 1 - getmaxx( w_terrain ) ) / 2,
1402 ( sight * 2 + 1 - getmaxy( w_terrain ) ) / 2 );
1403 if( maxoff.x <= 0 ) {
1404 offset.x = 0;
1405 } else if( offset.x > 0 && offset.x > maxoff.x ) {
1406 offset.x = maxoff.x;
1407 } else if( offset.x < 0 && -offset.x > maxoff.x ) {
1408 offset.x = -maxoff.x;
1409 }
1410 if( maxoff.y <= 0 ) {
1411 offset.y = 0;
1412 } else if( offset.y > 0 && offset.y > maxoff.y ) {
1413 offset.y = maxoff.y;
1414 } else if( offset.y < 0 && -offset.y > maxoff.y ) {
1415 offset.y = -maxoff.y;
1416 }
1417
1418 // Turn the offset into a vector that increments the offset toward the desired position
1419 // instead of setting it there instantly, should smooth out jerkiness.
1420 const point offset_difference( -driving_view_offset + point( offset.x, offset.y ) );
1421
1422 const point offset_sign( ( offset_difference.x < 0 ) ? -1 : 1,
1423 ( offset_difference.y < 0 ) ? -1 : 1 );
1424 // Shift the current offset in the direction of the calculated offset by one tile
1425 // per draw event, but snap to calculated offset if we're close enough to avoid jitter.
1426 offset.x = ( std::abs( offset_difference.x ) > 1 ) ?
1427 ( driving_view_offset.x + offset_sign.x ) : offset.x;
1428 offset.y = ( std::abs( offset_difference.y ) > 1 ) ?
1429 ( driving_view_offset.y + offset_sign.y ) : offset.y;
1430
1431 set_driving_view_offset( point( offset.x, offset.y ) );
1432}
int posz() const override
Definition: character.h:787
int sight_range(int light_level) const override
Returns the player's sight range.
Definition: character.cpp:719
point driving_view_offset
Definition: game.h:1045
catacurses::window w_terrain
Definition: game.h:1035
void set_driving_view_offset(const point &p)
Definition: game.cpp:1691
unsigned char light_level(int zlev) const
Returns coarse number-of-squares of visibility at the current light level.
Definition: game.cpp:3929
rl_vec2d move_vec() const
rl_vec2d face_vec() const
bool skidding
Definition: vehicle.h:1979
bool player_in_control(const Character &p) const
Definition: vehicle.cpp:277
int velocity
Definition: vehicle.h:1898
int cruise_velocity
Definition: vehicle.h:1900
static int veh_lumi(vehicle &veh)
Definition: game.cpp:1316
int getmaxx(const window &win)
Definition: ncurses_def.cpp:58
int getmaxy(const window &win)
Definition: ncurses_def.cpp:63
quantity< V, U > fabs(quantity< V, U > q)
Definition: units_def.h:136
constexpr float vmiph_per_tile
Definition: vehicle.h:68
static constexpr point point_zero
Definition: point.h:274
Definition: point.h:35
int y
Definition: point.h:39
int x
Definition: point.h:38
float y
Definition: point_float.h:13
float x
Definition: point_float.h:12

References vehicle::cruise_velocity, driving_view_offset, units::fabs(), vehicle::face_vec(), catacurses::getmaxx(), catacurses::getmaxy(), light_level(), vehicle::move_vec(), vehicle::player_in_control(), point_zero, Character::posz(), set_driving_view_offset(), Character::sight_range(), vehicle::skidding, u, veh_lumi(), vehicle::velocity, vehicles::vmiph_per_tile, w_terrain, point::x, rl_vec2d::x, point::y, and rl_vec2d::y.

Referenced by do_turn().

◆ cancel_activity_or_ignore_query()

bool game::cancel_activity_or_ignore_query ( distraction_type  type,
const std::string &  text 
)

Asks if the player wants to cancel their activity and if so cancels it.

Additionally checks if the player wants to ignore further distractions.

Definition at line 1792 of file game.cpp.

1793{
1795 if( u.has_distant_destination() ) {
1796 if( cancel_auto_move( u, text ) ) {
1797 return true;
1798 } else {
1800 return false;
1801 }
1802 }
1804 return false;
1805 }
1806 const bool force_uc = get_option<bool>( "FORCE_CAPITAL_YN" );
1807 const auto &allow_key = force_uc ? input_context::disallow_lower_case
1809
1810 const auto &action = query_popup()
1811 .context( "CANCEL_ACTIVITY_OR_IGNORE_QUERY" )
1812 .message( force_uc ?
1813 pgettext( "cancel_activity_or_ignore_query",
1814 "<color_light_red>%s %s (Case Sensitive)</color>" ) :
1815 pgettext( "cancel_activity_or_ignore_query",
1816 "<color_light_red>%s %s</color>" ),
1817 text, u.activity.get_stop_phrase() )
1818 .option( "YES", allow_key )
1819 .option( "NO", allow_key )
1820 .option( "IGNORE", allow_key )
1821 .query()
1822 .action;
1823
1824 if( action == "YES" ) {
1826 return true;
1827 }
1828 if( action == "IGNORE" ) {
1830 for( auto &activity : u.backlog ) {
1831 activity.ignore_distraction( type );
1832 }
1833 }
1834
1837
1838 return false;
1839}
void set_destination(const std::vector< tripoint > &route, const player_activity &new_destination_activity=player_activity())
void cancel_activity()
Definition: character.cpp:9246
std::vector< tripoint > & get_auto_move_route()
std::list< player_activity > backlog
Definition: character.h:1525
bool has_distant_destination() const
static const input_event_filter allow_all_keys
Definition: input.h:541
static const input_event_filter disallow_lower_case
Definition: input.h:540
bool is_distraction_ignored(distraction_type type) const
std::string get_stop_phrase() const
void ignore_distraction(distraction_type type)
UI class for displaying messages or querying player input with popups.
Definition: popup.h:39
query_popup & context(const std::string &cat)
Specify the input context.
Definition: popup.cpp:21
query_popup & option(const std::string &opt)
Specify an action as an option.
Definition: popup.cpp:28
result query()
Query until a valid action or an error happens and return the result.
Definition: popup.cpp:348
query_popup & message(const std::string &fmt, Args &&... args)
Specify the query message.
Definition: popup.h:91
@ action
Definition: dialogue.h:36
@ type
Definition: enums.h:75
static bool cancel_auto_move(player &p, const std::string &text)
Definition: game.cpp:1779
void redraw()
Definition: ui_manager.cpp:285
void refresh_display()
Make changes made to the display visible to the user immediately.
std::string action
Definition: popup.h:68
const char * pgettext(const char *context, const char *msgid)

References action, query_popup::result::action, Character::activity, input_context::allow_all_keys, Character::backlog, Character::cancel_activity(), cancel_auto_move(), query_popup::context(), input_context::disallow_lower_case, Character::get_auto_move_route(), player_activity::get_stop_phrase(), Character::has_distant_destination(), player_activity::ignore_distraction(), invalidate_main_ui_adaptor(), player_activity::is_distraction_ignored(), query_popup::message(), query_popup::option(), pgettext(), query_popup::query(), ui_manager::redraw(), refresh_display(), Character::set_destination(), type, and u.

Referenced by mon_info_update(), monmove(), and process_voluntary_act_interrupt().

◆ cancel_activity_query()

bool game::cancel_activity_query ( const std::string &  text)

Asks if the player wants to cancel their activity, and if so cancels it.

Definition at line 1841 of file game.cpp.

1842{
1844 if( u.has_distant_destination() ) {
1845 if( cancel_auto_move( u, text ) ) {
1846 return true;
1847 } else {
1849 return false;
1850 }
1851 }
1852 if( !u.activity ) {
1853 return false;
1854 }
1855 if( query_yn( "%s %s", text, u.activity.get_stop_phrase() ) ) {
1859 return true;
1860 }
1861 return false;
1862}
void clear_destination()
void resume_backlog_activity()
Definition: character.cpp:9278

References Character::activity, Character::cancel_activity(), cancel_auto_move(), Character::clear_destination(), Character::get_auto_move_route(), player_activity::get_stop_phrase(), Character::has_distant_destination(), invalidate_main_ui_adaptor(), query_yn(), Character::resume_backlog_activity(), Character::set_destination(), and u.

Referenced by handle_key_blocking_activity().

◆ catch_a_monster()

void game::catch_a_monster ( monster fish,
const tripoint pos,
player p,
const time_duration catch_duration 
)

Picks and spawns a random fish from the remaining fish list when a fish is caught.

Definition at line 1765 of file game.cpp.

1767{
1768 //spawn the corpse, rotten by a part of the duration
1770 catch_duration ) ) );
1771 if( u.sees( pos ) ) {
1772 u.add_msg_if_player( m_good, _( "You caught a %s." ), fish->type->nname() );
1773 }
1774 //quietly kill the caught
1775 fish->no_corpse_quiet = true;
1776 fish->die( p );
1777}
bool sees(const tripoint &t, bool is_player=false, int range_mod=0) const override
static item make_corpse(const mtype_id &mt=string_id< mtype >::NULL_ID(), time_point turn=calendar::turn, const std::string &name="", int upgrade_time=-1)
Make a corpse of the given monster type.
Definition: item.cpp:506
item & add_item_or_charges(const tripoint &pos, item obj, bool overflow=true)
Adds an item to map tile or stacks charges.
Definition: map.cpp:4214
bool no_corpse_quiet
Definition: monster.h:482
void die(Creature *killer) override
Empty function.
Definition: monster.cpp:2243
const mtype * type
Definition: monster.h:478
void add_msg_if_player(const std::string &msg) const override
Definition: player.cpp:4190
time_point turn
Definition: calendar.cpp:36
mtype_id id
Definition: mtype.h:240
std::string nname(unsigned int quantity=1) const
Definition: mtype.cpp:65

References _, map::add_item_or_charges(), player::add_msg_if_player(), monster::die(), mtype::id, m, m_good, item::make_corpse(), mtype::nname(), monster::no_corpse_quiet, rng(), Character::sees(), calendar::turn, monster::type, and u.

◆ chat()

void game::chat ( )
private

Definition at line 394 of file npctalk.cpp.

395{
396 int volume = g->u.get_shout_volume();
397
398 const std::vector<npc *> available = get_npcs_if( [&]( const npc & guy ) {
399 // TODO: Get rid of the z-level check when z-level vision gets "better"
400 return u.posz() == guy.posz() && u.sees( guy.pos() ) &&
401 rl_dist( u.pos(), guy.pos() ) <= SEEX * 2;
402 } );
403 const int available_count = available.size();
404 const std::vector<npc *> followers = get_npcs_if( [&]( const npc & guy ) {
405 return guy.is_player_ally() && guy.is_following() && guy.can_hear( u.pos(), volume );
406 } );
407 const int follower_count = followers.size();
408 const std::vector<npc *> guards = get_npcs_if( [&]( const npc & guy ) {
409 return guy.mission == NPC_MISSION_GUARD_ALLY &&
410 guy.companion_mission_role_id != "FACTION_CAMP" &&
411 guy.can_hear( u.pos(), volume );
412 } );
413 const int guard_count = guards.size();
414
415 if( g->u.has_trait( trait_PROF_FOODP ) && !( g->u.is_wearing( itype_id( "foodperson_mask" ) ) ||
416 g->u.is_wearing( itype_id( "foodperson_mask_on" ) ) ) ) {
417 g->u.add_msg_if_player( m_warning, _( "You can't speak without your face!" ) );
418 return;
419 }
420 std::vector<vehicle *> animal_vehicles;
421 std::vector<vehicle *> following_vehicles;
422 std::vector<vehicle *> magic_vehicles;
423 std::vector<vehicle *> magic_following_vehicles;
424 for( auto &veh : g->m.get_vehicles() ) {
425 auto &v = veh.v;
426 if( v->has_engine_type( fuel_type_animal, false ) && v->is_owned_by( g->u ) ) {
427 animal_vehicles.push_back( v );
428 if( v->is_following ) {
429 following_vehicles.push_back( v );
430 }
431 }
432 if( v->magic ) {
433 for( const vpart_reference &vp : v->get_all_parts() ) {
434 const vpart_info &vpi = vp.info();
435 if( vpi.has_flag( "MAGIC_FOLLOW" ) ) {
436 magic_vehicles.push_back( v );
437 if( v->is_following ) {
438 magic_following_vehicles.push_back( v );
439 }
440 break;
441 }
442 }
443 }
444 }
445
446 uilist nmenu;
447 nmenu.text = std::string( _( "What do you want to do?" ) );
448
449 if( !available.empty() ) {
450 nmenu.addentry( NPC_CHAT_TALK, true, 't', available_count == 1 ?
451 string_format( _( "Talk to %s" ), available.front()->name ) :
452 _( "Talk to…" )
453 );
454 }
455 nmenu.addentry( NPC_CHAT_YELL, true, 'a', _( "Yell" ) );
456 nmenu.addentry( NPC_CHAT_SENTENCE, true, 'b', _( "Yell a sentence" ) );
457 if( !animal_vehicles.empty() ) {
459 _( "Whistle at your animals pulling vehicles to follow you." ) );
460 }
461 if( !magic_vehicles.empty() ) {
463 _( "Utter a magical command that will order your magical vehicles to follow you." ) );
464 }
465 if( !magic_following_vehicles.empty() ) {
467 _( "Utter a magical command that will order your magical vehicles to stop following you." ) );
468 }
469 if( !following_vehicles.empty() ) {
471 _( "Whistle at your animals pulling vehicles to stop following you." ) );
472 }
473 if( !guards.empty() ) {
474 nmenu.addentry( NPC_CHAT_FOLLOW, true, 'f', guard_count == 1 ?
475 string_format( _( "Tell %s to follow" ), guards.front()->name ) :
476 _( "Tell someone to follow…" )
477 );
478 }
479 if( !followers.empty() ) {
480 nmenu.addentry( NPC_CHAT_GUARD, true, 'g', follower_count == 1 ?
481 string_format( _( "Tell %s to guard" ), followers.front()->name ) :
482 _( "Tell someone to guard…" )
483 );
484 nmenu.addentry( NPC_CHAT_AWAKE, true, 'w', _( "Tell everyone on your team to wake up" ) );
485 nmenu.addentry( NPC_CHAT_MOUNT, true, 'M', _( "Tell everyone on your team to mount up" ) );
486 nmenu.addentry( NPC_CHAT_DISMOUNT, true, 'm', _( "Tell everyone on your team to dismount" ) );
487 nmenu.addentry( NPC_CHAT_DANGER, true, 'D',
488 _( "Tell everyone on your team to prepare for danger" ) );
489 nmenu.addentry( NPC_CHAT_CLEAR_OVERRIDES, true, 'r',
490 _( "Tell everyone on your team to relax (Clear Overrides)" ) );
491 nmenu.addentry( NPC_CHAT_ORDERS, true, 'o', _( "Tell everyone on your team to temporarily…" ) );
492 }
493 std::string message;
494 std::string yell_msg;
495 bool is_order = true;
496 nmenu.query();
497
498 if( nmenu.ret < 0 ) {
499 return;
500 }
501
502 switch( nmenu.ret ) {
503 case NPC_CHAT_TALK: {
504 const int npcselect = npc_select_menu( available, _( "Talk to whom?" ), false );
505 if( npcselect < 0 ) {
506 return;
507 }
508 available[npcselect]->talk_to_u();
509 break;
510 }
511 case NPC_CHAT_YELL:
512 is_order = false;
513 message = _( "loudly." );
514 break;
515 case NPC_CHAT_SENTENCE: {
516 std::string popupdesc = _( "Enter a sentence to yell" );
518 popup.title( _( "Yell a sentence" ) )
519 .width( 64 )
520 .description( popupdesc )
521 .identifier( "sentence" )
522 .max_length( 128 )
523 .query();
524 yell_msg = popup.text();
525 is_order = false;
526 break;
527 }
528 case NPC_CHAT_GUARD: {
529 const int npcselect = npc_select_menu( followers, _( "Who should guard here?" ) );
530 if( npcselect < 0 ) {
531 return;
532 }
533 if( npcselect == follower_count ) {
534 for( npc *them : followers ) {
536 }
537 yell_msg = _( "Everyone guard here!" );
538 } else {
539 talk_function::assign_guard( *followers[npcselect] );
540 yell_msg = string_format( _( "Guard here, %s!" ), followers[npcselect]->name );
541 }
542 break;
543 }
544 case NPC_CHAT_FOLLOW: {
545 const int npcselect = npc_select_menu( guards, _( "Who should follow you?" ) );
546 if( npcselect < 0 ) {
547 return;
548 }
549 if( npcselect == guard_count ) {
550 for( npc *them : guards ) {
552 }
553 yell_msg = _( "Everyone follow me!" );
554 } else {
555 talk_function::stop_guard( *guards[npcselect] );
556 yell_msg = string_format( _( "Follow me, %s!" ), guards[npcselect]->name );
557 }
558 break;
559 }
560 case NPC_CHAT_AWAKE:
561 for( npc *them : followers ) {
562 talk_function::wake_up( *them );
563 }
564 yell_msg = _( "Stay awake!" );
565 break;
566 case NPC_CHAT_MOUNT:
567 for( npc *them : followers ) {
568 if( them->has_effect( effect_riding ) ) {
569 continue;
570 }
572 }
573 yell_msg = _( "Mount up!" );
574 break;
576 for( npc *them : followers ) {
577 if( them->has_effect( effect_riding ) ) {
578 them->npc_dismount();
579 }
580 }
581 yell_msg = _( "Dismount!" );
582 break;
583 case NPC_CHAT_DANGER:
584 for( npc *them : followers ) {
585 them->rules.set_danger_overrides();
586 }
587 yell_msg = _( "We're in danger. Stay awake, stay close, don't go wandering off, "
588 "and don't open any doors." );
589 break;
591 for( npc *p : followers ) {
593 }
594 yell_msg = _( "As you were." );
595 break;
596 case NPC_CHAT_ORDERS:
597 npc_temp_orders_menu( followers );
598 break;
601 break;
604 break;
607 break;
610 break;
611 default:
612 return;
613 }
614
615 if( !yell_msg.empty() ) {
616 message = string_format( "\"%s\"", yell_msg );
617 }
618 if( !message.empty() ) {
619 add_msg( _( "You yell %s" ), message );
620 u.shout( string_format( _( "%s yelling %s" ), u.disp_name(), message ), is_order );
621 }
622
623 u.moves -= 100;
624}
std::string disp_name(bool possessive=false, bool capitalize_first=false) const override
Returns either "you" or the player's name.
Definition: character.cpp:546
void shout(std::string msg="", bool order=false)
Definition: character.cpp:7743
bool can_hear(const tripoint &source, int volume) const
int moves
Definition: creature.h:569
std::string companion_mission_role_id
Definition: npc.h:1318
npc_mission mission
Definition: npc.h:1325
bool is_player_ally() const
Definition: npc.cpp:1984
bool is_following() const
Definition: npc.cpp:2015
Shows a window querying the user for input.
bool has_flag(const std::string &flag) const
Definition: veh_type.h:336
This is a wrapper over a vehicle pointer and a reference to a part of it.
int rl_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:519
static constexpr int SEEX
std::string message
Definition: mapgen.cpp:403
std::string name(type dir)
Get Human readable name of a direction.
Definition: overmap.cpp:4118
void wake_up(npc &)
void find_mount(npc &)
void clear_overrides(npc &p)
void stop_guard(npc &)
void assign_guard(npc &)
quantity< int, volume_in_milliliter_tag > volume
Definition: units_volume.h:16
@ NPC_MISSION_GUARD_ALLY
Definition: npc.h:187
static const efftype_id effect_riding("riding")
static const trait_id trait_PROF_FOODP("PROF_FOODP")
static int npc_select_menu(const std::vector< npc * > &npc_list, const std::string &prompt, const bool everyone=true)
Definition: npctalk.cpp:220
static void tell_magic_veh_stop_following()
Definition: npctalk.cpp:377
static void tell_veh_stop_following()
Definition: npctalk.cpp:340
static void assign_veh_to_follow()
Definition: npctalk.cpp:351
static void npc_temp_orders_menu(const std::vector< npc * > &npc_list)
Definition: npctalk.cpp:252
static const itype_id fuel_type_animal("animal")
@ NPC_CHAT_MOUNT
Definition: npctalk.cpp:200
@ NPC_CHAT_COMMAND_MAGIC_VEHICLE_STOP_FOLLOW
Definition: npctalk.cpp:214
@ NPC_CHAT_YELL
Definition: npctalk.cpp:195
@ NPC_CHAT_FOLLOW
Definition: npctalk.cpp:198
@ NPC_CHAT_GUARD
Definition: npctalk.cpp:197
@ NPC_CHAT_DISMOUNT
Definition: npctalk.cpp:201
@ NPC_CHAT_ANIMAL_VEHICLE_FOLLOW
Definition: npctalk.cpp:211
@ NPC_CHAT_ORDERS
Definition: npctalk.cpp:203
@ NPC_CHAT_SENTENCE
Definition: npctalk.cpp:196
@ NPC_CHAT_CLEAR_OVERRIDES
Definition: npctalk.cpp:210
@ NPC_CHAT_DANGER
Definition: npctalk.cpp:202
@ NPC_CHAT_AWAKE
Definition: npctalk.cpp:199
@ NPC_CHAT_ANIMAL_VEHICLE_STOP_FOLLOW
Definition: npctalk.cpp:212
@ NPC_CHAT_TALK
Definition: npctalk.cpp:194
@ NPC_CHAT_COMMAND_MAGIC_VEHICLE_FOLLOW
Definition: npctalk.cpp:213
static void tell_magic_veh_to_follow()
Definition: npctalk.cpp:361
int popup(const std::string &text, PopupFlags flags)
Definition: output.cpp:764

References _, add_msg(), uilist::addentry(), talk_function::assign_guard(), assign_veh_to_follow(), available, Character::can_hear(), talk_function::clear_overrides(), npc::companion_mission_role_id, Character::disp_name(), effect_riding, talk_function::find_mount(), fuel_type_animal, g, get_npcs_if(), vpart_info::has_flag(), npc::is_following(), npc::is_player_ally(), m_warning, mapgen_defer::message, npc::mission, Creature::moves, om_direction::name(), NPC_CHAT_ANIMAL_VEHICLE_FOLLOW, NPC_CHAT_ANIMAL_VEHICLE_STOP_FOLLOW, NPC_CHAT_AWAKE, NPC_CHAT_CLEAR_OVERRIDES, NPC_CHAT_COMMAND_MAGIC_VEHICLE_FOLLOW, NPC_CHAT_COMMAND_MAGIC_VEHICLE_STOP_FOLLOW, NPC_CHAT_DANGER, NPC_CHAT_DISMOUNT, NPC_CHAT_FOLLOW, NPC_CHAT_GUARD, NPC_CHAT_MOUNT, NPC_CHAT_ORDERS, NPC_CHAT_SENTENCE, NPC_CHAT_TALK, NPC_CHAT_YELL, NPC_MISSION_GUARD_ALLY, npc_select_menu(), npc_temp_orders_menu(), popup(), Character::pos(), Character::posz(), uilist::query(), uilist::ret, rl_dist(), Character::sees(), SEEX, Character::shout(), talk_function::stop_guard(), string_format(), tell_magic_veh_stop_following(), tell_magic_veh_to_follow(), tell_veh_stop_following(), uilist::text, trait_PROF_FOODP, u, and talk_function::wake_up().

Referenced by handle_action().

◆ check_mod_data()

bool game::check_mod_data ( const std::vector< mod_id > &  opts,
loading_ui ui 
)

Check if mods can be successfully loaded.

Parameters
optscheck specific mods (or all if unspecified)
Returns
whether all mods were successfully loaded

Definition at line 345 of file game.cpp.

346{
347 auto &tree = world_generator->get_mod_manager().get_tree();
348
349 // deduplicated list of mods to check
350 std::set<mod_id> check( opts.begin(), opts.end() );
351
352 // if no specific mods specified check all non-obsolete mods
353 if( check.empty() ) {
354 for( const mod_id &e : world_generator->get_mod_manager().all_mods() ) {
355 if( !e->obsolete ) {
356 check.emplace( e );
357 }
358 }
359 }
360
361 if( check.empty() ) {
362 world_generator->set_active_world( nullptr );
363 world_generator->init();
364 const std::vector<mod_id> mods_empty;
365 WORLDPTR test_world = world_generator->make_new_world( mods_empty );
366 world_generator->set_active_world( test_world );
367
368 // if no loadable mods then test core data only
369 try {
372 } catch( const std::exception &err ) {
373 std::cerr << "Error loading data from json: " << err.what() << std::endl;
374 }
375
376 std::string world_name = world_generator->active_world->world_name;
377 world_generator->delete_world( world_name, true );
378
381 }
382
383 for( const auto &e : check ) {
384 world_generator->set_active_world( nullptr );
385 world_generator->init();
386 const std::vector<mod_id> mods_empty;
387 WORLDPTR test_world = world_generator->make_new_world( mods_empty );
388 if( !test_world ) {
389 std::cerr << "Failed to generate test world." << std::endl;
390 return false;
391 }
392 world_generator->set_active_world( test_world );
393
394 if( !e.is_valid() ) {
395 std::cerr << "Unknown mod: " << e.str() << std::endl;
396 return false;
397 }
398
399 const MOD_INFORMATION &mod = *e;
400
401 if( !tree.is_available( mod.ident ) ) {
402 std::cerr << "Missing dependencies: " << mod.name() << "\n"
403 << tree.get_node( mod.ident )->s_errors() << std::endl;
404 return false;
405 }
406
407 std::cout << "Checking mod " << mod.name() << " [" << mod.ident.str() << "]" << std::endl;
408
409 try {
411
412 // Load any dependencies
413 for( auto &dep : tree.get_dependencies_of_X_as_strings( mod.ident ) ) {
414 load_data_from_dir( dep->path, dep->ident.str(), ui );
415 }
416
417 // Load mod itself
418 load_data_from_dir( mod.path, mod.ident.str(), ui );
420 } catch( const std::exception &err ) {
421 std::cerr << "Error loading data: " << err.what() << std::endl;
422 }
423
424 std::string world_name = world_generator->active_world->world_name;
425 world_generator->delete_world( world_name, true );
426
429 }
430 return true;
431}
void finalize_loaded_data(loading_ui &ui)
Called to finalize the loaded data.
Definition: init.cpp:627
static DynamicDataLoader & get_instance()
Returns the single instance of this class.
Definition: init.cpp:112
void load_data_from_dir(const std::string &path, const std::string &src, loading_ui &ui)
Loads dynamic data from the given directory.
Definition: game.cpp:447
void load_core_data(loading_ui &ui)
Loads core dynamic data.
Definition: game.cpp:438
void reset()
Delete all buffered submaps.
Definition: mapbuffer.cpp:49
int check(unformattable)
Definition: fmtlib_core.h:1610
Definition: overmap_ui.h:17
overmapbuffer overmap_buffer

References detail::check(), overmapbuffer::clear(), DynamicDataLoader::finalize_loaded_data(), DynamicDataLoader::get_instance(), load_core_data(), load_data_from_dir(), MAPBUFFER, overmap_buffer, mapbuffer::reset(), and world_generator.

◆ check_near_zone()

bool game::check_near_zone ( const zone_type_id type,
const tripoint where 
) const

Checks whether or not there is a zone of particular type nearby.

Definition at line 6302 of file game.cpp.

6303{
6304 return zone_manager::get_manager().has_near( type, m.getabs( where ) );
6305}
static zone_manager & get_manager()
Definition: clzones.cpp:125
bool has_near(const zone_type_id &type, const tripoint &where, int range=MAX_DISTANCE, const faction_id &fac=your_fac) const
Definition: clzones.cpp:702

References zone_manager::get_manager(), map::getabs(), zone_manager::has_near(), m, and type.

◆ check_safe_mode_allowed()

bool game::check_safe_mode_allowed ( bool  repeat_safe_mode_warnings = true)

Check whether movement is allowed according to safe mode settings.

Returns
true if the movement is allowed, otherwise false.

Definition at line 9122 of file game.cpp.

9123{
9124 if( !repeat_safe_mode_warnings && safe_mode_warning_logged ) {
9125 // Already warned player since safe_mode_warning_logged is set.
9126 return false;
9127 }
9128
9129 std::string msg_ignore = press_x( ACTION_IGNORE_ENEMY );
9130 if( !msg_ignore.empty() ) {
9131 std::wstring msg_ignore_wide = utf8_to_wstr( msg_ignore );
9132 // Operate on a wide-char basis to prevent corrupted multi-byte string
9133 msg_ignore_wide[0] = towlower( msg_ignore_wide[0] );
9134 msg_ignore = wstr_to_utf8( msg_ignore_wide );
9135 }
9136
9138 // Automatic and mandatory safemode. Make BLOODY sure the player notices!
9139 if( u.get_int_base() < 5 || u.has_trait( trait_id( "PROF_CHURL" ) ) ) {
9141 _( "There's an angry red dot on your body, %s to brush it off." ), msg_ignore );
9142 } else {
9144 _( "You are being laser-targeted, %s to ignore." ), msg_ignore );
9145 }
9147 return false;
9148 }
9149 if( safe_mode != SAFE_MODE_STOP ) {
9150 return true;
9151 }
9152 // Currently driving around, ignore the monster, they have no chance against a proper car anyway (-:
9153 if( u.controlling_vehicle && !get_option<bool>( "SAFEMODEVEH" ) ) {
9154 return true;
9155 }
9156 // Monsters around and we don't want to run
9157 std::string spotted_creature_name;
9158 const monster_visible_info &mon_visible = u.get_mon_visible();
9159 const auto &new_seen_mon = mon_visible.new_seen_mon;
9160
9161 if( new_seen_mon.empty() ) {
9162 // naming consistent with code in game::mon_info
9163 spotted_creature_name = _( "a survivor" );
9165 } else {
9166 spotted_creature_name = new_seen_mon.back()->name();
9167 get_safemode().lastmon_whitelist = spotted_creature_name;
9168 }
9169
9170 std::string whitelist;
9171 if( !get_safemode().empty() ) {
9172 whitelist = string_format( _( " or %s to whitelist the monster" ),
9174 }
9175
9176 const std::string msg_safe_mode = press_x( ACTION_TOGGLE_SAFEMODE );
9178 _( "Spotted %1$s--safe mode is on! (%2$s to turn it off, %3$s to ignore monster%4$s)" ),
9179 spotted_creature_name, msg_safe_mode, msg_ignore, whitelist );
9181 return false;
9182}
std::string press_x(action_id act)
Definition: action.cpp:451
@ ACTION_IGNORE_ENEMY
Ignore the enemy that triggered safemode.
Definition: action.h:221
@ ACTION_WHITELIST_ENEMY
Whitelist the enemy that triggered safemode.
Definition: action.h:223
@ ACTION_TOGGLE_SAFEMODE
Turn safemode on/off, while leaving autosafemode intact.
Definition: action.h:215
std::wstring utf8_to_wstr(const std::string &str)
std::string wstr_to_utf8(const std::wstring &wstr)
bool has_trait(const trait_id &b) const override
Returns true if the player has the entered trait.
Definition: mutation.cpp:103
bool has_effect(const efftype_id &eff_id, body_part bp=num_bp) const
Check if creature has the matching effect.
Definition: creature.cpp:1176
int get_int_base() const override
Definition: avatar.cpp:1009
monster_visible_info & get_mon_visible()
Definition: avatar.h:213
std::string lastmon_whitelist
Definition: safemode_ui.h:87
std::string npc_type_name()
Definition: safemode_ui.cpp:44
@ gmf_bypass_cooldown
Definition: enums.h:281
static const efftype_id effect_laserlocked("laserlocked")
@ SAFE_MODE_STOP
Definition: game.h:79
safemode & get_safemode()
Definition: safemode_ui.cpp:33
Structure allowing a combination of game_message_type and game_message_flags.
Definition: enums.h:286
std::vector< shared_ptr_fast< monster > > new_seen_mon
Definition: avatar.h:40

References _, ACTION_IGNORE_ENEMY, ACTION_TOGGLE_SAFEMODE, ACTION_WHITELIST_ENEMY, add_msg(), Character::controlling_vehicle, effect_laserlocked, avatar::get_int_base(), avatar::get_mon_visible(), get_safemode(), gmf_bypass_cooldown, Creature::has_effect(), Character::has_trait(), safemode::lastmon_whitelist, m_warning, monster_visible_info::new_seen_mon, safemode::npc_type_name(), press_x(), safe_mode, SAFE_MODE_STOP, safe_mode_warning_logged, string_format(), u, utf8_to_wstr(), and wstr_to_utf8().

Referenced by handle_action().

◆ check_zone()

bool game::check_zone ( const zone_type_id type,
const tripoint where 
) const

Definition at line 6297 of file game.cpp.

6298{
6299 return zone_manager::get_manager().has( type, m.getabs( where ) );
6300}
bool has(const zone_type_id &type, const tripoint &where, const faction_id &fac=your_fac) const
Definition: clzones.cpp:694

References zone_manager::get_manager(), map::getabs(), zone_manager::has(), m, and type.

Referenced by place_player().

◆ cleanup_at_end()

bool game::cleanup_at_end ( )

Definition at line 1030 of file game.cpp.

1031{
1032 if( uquit == QUIT_DIED || uquit == QUIT_SUICIDE ) {
1033 // Put (non-hallucinations) into the overmap so they are not lost.
1034 for( monster &critter : all_monsters() ) {
1035 despawn_monster( critter );
1036 }
1037 // Reset NPC factions and disposition
1039 // Save the factions', missions and set the NPC's overmap coordinates
1040 // Npcs are saved in the overmap.
1041 save_factions_missions_npcs(); //missions need to be saved as they are global for all saves.
1042 // save artifacts.
1044
1045 // and the overmap, and the local map.
1046 save_maps(); //Omap also contains the npcs who need to be saved.
1047 }
1048
1049 if( uquit == QUIT_DIED || uquit == QUIT_SUICIDE ) {
1050 std::vector<std::string> vRip;
1051
1052 int iMaxWidth = 0;
1053 int iNameLine = 0;
1054 int iInfoLine = 0;
1055
1058 if( !( u.has_trait( trait_id( "CANNIBAL" ) ) || u.has_trait( trait_id( "PSYCHOPATH" ) ) ) ) {
1059 vRip.emplace_back( " _______ ___" );
1060 vRip.emplace_back( " < `/ |" );
1061 vRip.emplace_back( " > _ _ (" );
1062 vRip.emplace_back( " | |_) | |_) |" );
1063 vRip.emplace_back( " | | \\ | | |" );
1064 vRip.emplace_back( " ______.__%_| |_________ __" );
1065 vRip.emplace_back( " _/ \\| |" );
1066 iNameLine = vRip.size();
1067 vRip.emplace_back( "| <" );
1068 vRip.emplace_back( "| |" );
1069 iMaxWidth = utf8_width( vRip.back() );
1070 vRip.emplace_back( "| |" );
1071 vRip.emplace_back( "|_____.-._____ __/|_________|" );
1072 vRip.emplace_back( " | |" );
1073 iInfoLine = vRip.size();
1074 vRip.emplace_back( " | |" );
1075 vRip.emplace_back( " | <" );
1076 vRip.emplace_back( " | |" );
1077 vRip.emplace_back( " | _ |" );
1078 vRip.emplace_back( " |__/ |" );
1079 vRip.emplace_back( " % / `--. |%" );
1080 vRip.emplace_back( " * .%%| -< @%%%" ); // NOLINT(cata-text-style)
1081 vRip.emplace_back( " `\\%`@| |@@%@%%" );
1082 vRip.emplace_back( " .%%%@@@|% ` % @@@%%@%%%%" );
1083 vRip.emplace_back( " _.%%%%%%@@@@@@%%%__/\\%@@%%@@@@@@@%%%%%%" );
1084
1085 } else {
1086 vRip.emplace_back( " _______ ___" );
1087 vRip.emplace_back( " | \\/ |" );
1088 vRip.emplace_back( " | |" );
1089 vRip.emplace_back( " | |" );
1090 iInfoLine = vRip.size();
1091 vRip.emplace_back( " | |" );
1092 vRip.emplace_back( " | |" );
1093 vRip.emplace_back( " | |" );
1094 vRip.emplace_back( " | |" );
1095 vRip.emplace_back( " | <" );
1096 vRip.emplace_back( " | _ |" );
1097 vRip.emplace_back( " |__/ |" );
1098 vRip.emplace_back( " ______.__%_| |__________ _" );
1099 vRip.emplace_back( " _/ \\| \\" );
1100 iNameLine = vRip.size();
1101 vRip.emplace_back( "| <" );
1102 vRip.emplace_back( "| |" );
1103 iMaxWidth = utf8_width( vRip.back() );
1104 vRip.emplace_back( "| |" );
1105 vRip.emplace_back( "|_____.-._______ __/|__________|" );
1106 vRip.emplace_back( " % / `_-. _ |%" );
1107 vRip.emplace_back( " * .%%| |_) | |_)< @%%%" ); // NOLINT(cata-text-style)
1108 vRip.emplace_back( " `\\%`@| | \\ | | |@@%@%%" );
1109 vRip.emplace_back( " .%%%@@@|% ` % @@@%%@%%%%" );
1110 vRip.emplace_back( " _.%%%%%%@@@@@@%%%__/\\%@@%%@@@@@@@%%%%%%" );
1111 }
1112 } else {
1113 vRip.emplace_back( R"( _________ ____ )" );
1114 vRip.emplace_back( R"( _/ `/ \_ )" );
1115 vRip.emplace_back( R"( _/ _ _ \_. )" );
1116 vRip.emplace_back( R"( _%\ |_) | |_) \_ )" );
1117 vRip.emplace_back( R"( _/ \/ | \ | | \_ )" );
1118 vRip.emplace_back( R"( _/ \_ )" );
1119 vRip.emplace_back( R"(| |)" );
1120 iNameLine = vRip.size();
1121 vRip.emplace_back( R"( ) < )" );
1122 vRip.emplace_back( R"(| |)" );
1123 vRip.emplace_back( R"(| |)" );
1124 vRip.emplace_back( R"(| _ |)" );
1125 vRip.emplace_back( R"(|__/ |)" );
1126 iMaxWidth = utf8_width( vRip.back() );
1127 vRip.emplace_back( R"( / `--. |)" );
1128 vRip.emplace_back( R"(| ( )" );
1129 iInfoLine = vRip.size();
1130 vRip.emplace_back( R"(| |)" );
1131 vRip.emplace_back( R"(| |)" );
1132 vRip.emplace_back( R"(| % . |)" );
1133 vRip.emplace_back( R"(| @` %% |)" );
1134 vRip.emplace_back( R"(| %@%@%\ * %`%@%|)" );
1135 vRip.emplace_back( R"(%%@@@.%@%\%% `\ %%.%%@@%@)" );
1136 vRip.emplace_back( R"(@%@@%%%%%@@@@@@%%%%%%%%@@%%@@@%%%@%%@)" );
1137 }
1138
1139 const int iOffsetX = TERMX > FULL_SCREEN_WIDTH ? ( TERMX - FULL_SCREEN_WIDTH ) / 2 : 0;
1140 const int iOffsetY = TERMY > FULL_SCREEN_HEIGHT ? ( TERMY - FULL_SCREEN_HEIGHT ) / 2 : 0;
1141
1143 point( iOffsetX, iOffsetY ) );
1144 draw_border( w_rip );
1145
1146 sfx::do_player_death_hurt( g->u, true );
1151
1152 for( size_t iY = 0; iY < vRip.size(); ++iY ) {
1153 size_t iX = 0;
1154 const char *str = vRip[iY].data();
1155 for( int slen = vRip[iY].size(); slen > 0; ) {
1156 const uint32_t cTemp = UTF8_getch( &str, &slen );
1157 if( cTemp != U' ' ) {
1158 nc_color ncColor = c_light_gray;
1159
1160 if( cTemp == U'%' ) {
1161 ncColor = c_green;
1162
1163 } else if( cTemp == U'_' || cTemp == U'|' ) {
1164 ncColor = c_white;
1165
1166 } else if( cTemp == U'@' ) {
1167 ncColor = c_brown;
1168
1169 } else if( cTemp == U'*' ) {
1170 ncColor = c_red;
1171 }
1172
1173 mvwputch( w_rip, point( iX + FULL_SCREEN_WIDTH / 2 - ( iMaxWidth / 2 ), iY + 1 ), ncColor,
1174 cTemp );
1175 }
1176 iX += mk_wcwidth( cTemp );
1177 }
1178 }
1179
1180 std::string sTemp;
1181
1182 center_print( w_rip, iInfoLine++, c_white, _( "Survived:" ) );
1183
1185 const int minutes = to_minutes<int>( survived ) % 60;
1186 const int hours = to_hours<int>( survived ) % 24;
1187 const int days = to_days<int>( survived );
1188
1189 if( days > 0 ) {
1190 sTemp = string_format( "%dd %dh %dm", days, hours, minutes );
1191 } else if( hours > 0 ) {
1192 sTemp = string_format( "%dh %dm", hours, minutes );
1193 } else {
1194 sTemp = string_format( "%dm", minutes );
1195 }
1196
1197 center_print( w_rip, iInfoLine++, c_white, sTemp );
1198
1199 const int iTotalKills = get_kill_tracker().monster_kill_count();
1200
1201 sTemp = _( "Kills:" );
1202 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - 5, 1 + iInfoLine++ ), c_light_gray,
1203 ( sTemp + " " ) );
1204 wprintz( w_rip, c_magenta, "%d", iTotalKills );
1205
1206 sTemp = _( "In memory of:" );
1207 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ),
1209 sTemp );
1210
1211 sTemp = u.name;
1212 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ), c_white,
1213 sTemp );
1214
1215 sTemp = _( "Last Words:" );
1216 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ),
1218 sTemp );
1219
1220 int iStartX = FULL_SCREEN_WIDTH / 2 - ( ( iMaxWidth - 4 ) / 2 );
1221 std::string sLastWords = string_input_popup()
1222 .window( w_rip, point( iStartX, iNameLine ), iStartX + iMaxWidth - 4 - 1 )
1223 .max_length( iMaxWidth - 4 - 1 )
1224 .query_string();
1225 death_screen();
1226 const bool is_suicide = uquit == QUIT_SUICIDE;
1227 events().send<event_type::game_over>( is_suicide, sLastWords );
1228 // Struck the save_player_data here to forestall Weirdness
1229 std::string char_filename = generate_memorial_filename( u.name );
1230 move_save_to_graveyard( char_filename );
1231 write_memorial_file( char_filename, sLastWords );
1232 memorial().clear();
1233 std::vector<std::string> characters = list_active_characters();
1234 // remove current player from the active characters list, as they are dead
1235 std::vector<std::string>::iterator curchar = std::find( characters.begin(),
1236 characters.end(), u.name );
1237 if( curchar != characters.end() ) {
1238 characters.erase( curchar );
1239 }
1240
1241 if( characters.empty() ) {
1242 bool queryDelete = false;
1243 bool queryReset = false;
1244
1245 if( get_option<std::string>( "WORLD_END" ) == "query" ) {
1246 bool decided = false;
1247 std::string buffer = _( "Warning: NPC interactions and some other global flags "
1248 "will not all reset when starting a new character in an "
1249 "already-played world. This can lead to some strange "
1250 "behavior.\n\n"
1251 "Are you sure you wish to keep this world?"
1252 );
1253
1254 while( !decided ) {
1255 uilist smenu;
1256 smenu.allow_cancel = false;
1257 smenu.addentry( 0, true, 'r', "%s", _( "Reset world" ) );
1258 smenu.addentry( 1, true, 'd', "%s", _( "Delete world" ) );
1259 smenu.addentry( 2, true, 'k', "%s", _( "Keep world" ) );
1260 smenu.query();
1261
1262 switch( smenu.ret ) {
1263 case 0:
1264 queryReset = true;
1265 decided = true;
1266 break;
1267 case 1:
1268 queryDelete = true;
1269 decided = true;
1270 break;
1271 case 2:
1272 decided = query_yn( buffer );
1273 break;
1274 }
1275 }
1276 }
1277
1278 if( queryDelete || get_option<std::string>( "WORLD_END" ) == "delete" ) {
1279 world_generator->delete_world( world_generator->active_world->world_name, true );
1280
1281 } else if( queryReset || get_option<std::string>( "WORLD_END" ) == "reset" ) {
1282 world_generator->delete_world( world_generator->active_world->world_name, false );
1283 }
1284 } else if( get_option<std::string>( "WORLD_END" ) != "keep" ) {
1285 std::string tmpmessage;
1286 for( auto &character : characters ) {
1287 tmpmessage += "\n ";
1288 tmpmessage += character;
1289 }
1290 popup( _( "World retained. Characters remaining:%s" ), tmpmessage );
1291 }
1292 if( gamemode ) {
1293 gamemode = std::make_unique<special_game>(); // null gamemode or something..
1294 }
1295 }
1296
1297 //Reset any offset due to driving
1299
1300 //clear all sound channels
1306
1307 MAPBUFFER.reset();
1309
1310#if defined(__ANDROID__)
1311 quick_shortcuts_map.clear();
1312#endif
1313 return true;
1314}
uint32_t UTF8_getch(const char **src, int *srclen)
Definition: catacharset.cpp:18
int utf8_width(const char *s, const bool ignore_tags)
std::string name
Definition: character.h:1512
A wrapper over a pointer to a curses window.
Definition: cursesdef.h:55
void send(const cata::event &) const
Definition: event_bus.cpp:58
void move_save_to_graveyard(const std::string &dirname)
Definition: game.cpp:2788
bool save_maps()
Definition: game.cpp:3052
std::unique_ptr< special_game > gamemode
Definition: game.h:1103
void death_screen()
Definition: game.cpp:2738
monster_range all_monsters()
Same as all_creatures but iterators only over monsters.
Definition: game.cpp:12519
bool save_factions_missions_npcs()
Definition: game.cpp:3038
void despawn_monster(monster &critter)
Despawn a specific monster, it's stored on the overmap.
Definition: game.cpp:11544
const kill_tracker & get_kill_tracker() const
Definition: game.cpp:968
void write_memorial_file(const std::string &filename, std::string sLastWords)
Writes information about the character out to a text file timestamped with the time of the file was m...
Definition: game.cpp:3151
std::vector< std::string > list_active_characters()
Returns a list of currently active character saves.
Definition: game.cpp:3136
bool save_artifacts()
Definition: game.cpp:3046
memorial_logger & memorial()
Definition: game.cpp:3101
void reset_npc_dispositions()
Definition: game.cpp:3010
int monster_kill_count() const
string_input_popup & max_length(int value)
Maximal amount of Unicode characters that can be given by the user.
const std::string & query_string(bool loop=true, bool draw_only=false)
string_input_popup & window(const catacurses::window &w, const point &start, int endx)
Set the window area where to display the input text.
A duration defined as a number of specific time units.
Definition: calendar.h:180
bool allow_cancel
Definition: ui.h:362
bool has_amount(const itype_id &what, int qty, bool pseudo=true, const std::function< bool(const item &)> &filter=return_true< item >) const
Check instance provides at least qty of an item (.
Definition: visitable.cpp:1108
#define c_white
Definition: color.h:18
#define c_light_gray
Definition: color.h:19
#define c_green
Definition: color.h:22
#define c_magenta
Definition: color.h:25
#define c_brown
Definition: color.h:26
#define c_red
Definition: color.h:21
static const itype_id itype_holybook_bible1("holybook_bible1")
static std::string generate_memorial_filename(const std::string &char_name)
Definition: game.cpp:1003
static const itype_id itype_holybook_bible2("holybook_bible2")
static const itype_id itype_holybook_bible3("holybook_bible3")
@ QUIT_DIED
Definition: game.h:72
@ QUIT_SUICIDE
Definition: game.h:69
const time_point & start_of_cataclysm
Definition: calendar.cpp:33
window newwin(int nlines, int ncols, const point &begin)
Definition: ncurses_def.cpp:34
FMT_CONSTEXPR bool find(Ptr first, Ptr last, T value, Ptr &out)
const size_t size
Definition: om_direction.h:27
void do_player_death_hurt(const player &target, bool death)
Definition: sounds.cpp:1633
void fade_audio_channel(channel channel, int duration)
Definition: sounds.cpp:1618
void fade_audio_group(group group, int duration)
Definition: sounds.cpp:1617
int TERMX
Definition: output.cpp:47
void mvwprintz(const catacurses::window &w, const point &p, const nc_color &FG, const std::string &text)
Definition: output.cpp:2035
int FULL_SCREEN_HEIGHT
Definition: output.cpp:56
int TERMY
Definition: output.cpp:48
void center_print(const catacurses::window &w, const int y, const nc_color &FG, const std::string &text)
Definition: output.cpp:446
void wprintz(const catacurses::window &w, const nc_color &FG, const std::string &text)
Definition: output.cpp:2043
int FULL_SCREEN_WIDTH
Definition: output.cpp:55
void mvwputch(const catacurses::window &w, const point &p, nc_color FG, int ch)
Definition: output.cpp:477
void draw_border(const catacurses::window &w, nc_color border_color, const std::string &title, nc_color title_color)
Definition: output.cpp:575
int mk_wcwidth(uint32_t ucs)
Definition: wcwidth.cpp:94

References _, uilist::addentry(), all_monsters(), uilist::allow_cancel, sfx::any, c_brown, c_green, c_light_gray, c_magenta, c_red, c_white, center_print(), memorial_logger::clear(), overmapbuffer::clear(), sfx::context_themes, death_screen(), despawn_monster(), sfx::do_player_death_hurt(), draw_border(), events(), sfx::fade_audio_channel(), sfx::fade_audio_group(), sfx::fatigue, detail::find(), FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, g, game_over, gamemode, generate_memorial_filename(), get_kill_tracker(), visitable< T >::has_amount(), Character::has_trait(), itype_holybook_bible1, itype_holybook_bible2, itype_holybook_bible3, list_active_characters(), MAPBUFFER, string_input_popup::max_length(), memorial(), mk_wcwidth(), kill_tracker::monster_kill_count(), move_save_to_graveyard(), mvwprintz(), mvwputch(), Character::name, catacurses::newwin(), overmap_buffer, point_zero, popup(), uilist::query(), string_input_popup::query_string(), query_yn(), QUIT_DIED, QUIT_SUICIDE, mapbuffer::reset(), reset_npc_dispositions(), uilist::ret, save_artifacts(), save_factions_missions_npcs(), save_maps(), event_bus::send(), set_driving_view_offset(), om_direction::size, calendar::start_of_cataclysm, string_format(), TERMX, TERMY, sfx::time_of_day, calendar::turn, u, uquit, UTF8_getch(), utf8_width(), sfx::weather, string_input_popup::window(), world_generator, wprintz(), and write_memorial_file().

Referenced by do_turn().

◆ cleanup_dead()

void game::cleanup_dead ( )

Definition at line 4377 of file game.cpp.

4378{
4379 // Dead monsters need to stay in the tracker until everything else that needs to die does so
4380 // This is because dying monsters can still interact with other dying monsters (@ref Creature::killer)
4381 bool monster_is_dead = critter_tracker->kill_marked_for_death();
4382
4383 bool npc_is_dead = false;
4384 // can't use all_npcs as that does not include dead ones
4385 for( const auto &n : active_npc ) {
4386 if( n->is_dead() ) {
4387 n->die( nullptr ); // make sure this has been called to create corpses etc.
4388 npc_is_dead = true;
4389 }
4390 }
4391
4392 if( monster_is_dead ) {
4393 // From here on, pointers to creatures get invalidated as dead creatures get removed.
4394 critter_tracker->remove_dead();
4395 }
4396
4397 if( npc_is_dead ) {
4398 for( auto it = active_npc.begin(); it != active_npc.end(); ) {
4399 if( ( *it )->is_dead() ) {
4400 remove_npc_follower( ( *it )->getID() );
4401 overmap_buffer.remove_npc( ( *it )->getID() );
4402 it = active_npc.erase( it );
4403 } else {
4404 it++;
4405 }
4406 }
4407 }
4408
4409 critter_died = false;
4410}
void remove_npc_follower(const character_id &id)
Remove follower id from follower set.
Definition: game.cpp:1966
pimpl< Creature_tracker > critter_tracker
Definition: game.h:1021
std::list< shared_ptr_fast< npc > > active_npc
Definition: game.h:1085
bool critter_died
Has anything died in this turn and needs to be cleaned up?
Definition: game.h:1097
shared_ptr_fast< npc > remove_npc(const character_id &id)
Find npc by id and if found, erase it from the npc list and return it ( or return nullptr if not foun...

References active_npc, critter_died, critter_tracker, overmap_buffer, overmapbuffer::remove_npc(), and remove_npc_follower().

Referenced by do_turn(), and monmove().

◆ clear_zombies()

void game::clear_zombies ( )

Redirects to the creature_tracker clear() function.

Definition at line 5043 of file game.cpp.

5044{
5045 critter_tracker->clear();
5046}

References critter_tracker.

Referenced by setup().

◆ control_vehicle()

void game::control_vehicle ( )
private

Definition at line 5457 of file game.cpp.

5458{
5459 static const itype_id fuel_type_animal( "animal" );
5460 int veh_part = -1;
5461 vehicle *veh = remoteveh();
5462 if( veh == nullptr ) {
5463 if( const optional_vpart_position vp = m.veh_at( u.pos() ) ) {
5464 veh = &vp->vehicle();
5465 veh_part = vp->part_index();
5466 }
5467 }
5468 if( veh != nullptr && veh->player_in_control( u ) &&
5469 veh->avail_part_with_feature( veh_part, "CONTROLS", true ) >= 0 ) {
5470 veh->use_controls( u.pos() );
5471 } else if( veh && veh->player_in_control( u ) &&
5472 veh->avail_part_with_feature( veh_part, "CONTROL_ANIMAL", true ) >= 0 ) {
5473 u.controlling_vehicle = false;
5474 add_msg( m_info, _( "You let go of the reins." ) );
5475 } else if( veh && ( veh->avail_part_with_feature( veh_part, "CONTROLS", true ) >= 0 ||
5476 ( veh->avail_part_with_feature( veh_part, "CONTROL_ANIMAL", true ) >= 0 &&
5477 veh->has_engine_type( fuel_type_animal, false ) && veh->has_harnessed_animal() ) ) &&
5478 u.in_vehicle ) {
5479 if( u.has_trait( trait_WAYFARER ) ) {
5480 add_msg( m_info, _( "You refuse to take control of this vehicle." ) );
5481 return;
5482 }
5483 if( !veh->interact_vehicle_locked() ) {
5484 veh->handle_potential_theft( dynamic_cast<player &>( u ) );
5485 return;
5486 }
5487 if( veh->engine_on ) {
5488 if( !veh->handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
5489 return;
5490 }
5491 u.controlling_vehicle = true;
5492 add_msg( _( "You take control of the %s." ), veh->name );
5493 } else {
5494 if( !veh->handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
5495 return;
5496 }
5497 veh->start_engines( true );
5498 }
5499 } else { // Start looking for nearby vehicle controls.
5500 int num_valid_controls = 0;
5501 cata::optional<tripoint> vehicle_position;
5502 cata::optional<vpart_reference> vehicle_controls;
5503 for( const tripoint elem : m.points_in_radius( g->u.pos(), 1 ) ) {
5504 if( const optional_vpart_position vp = m.veh_at( elem ) ) {
5505 const cata::optional<vpart_reference> controls = vp.value().part_with_feature( "CONTROLS", true );
5506 if( controls ) {
5507 num_valid_controls++;
5508 vehicle_position = elem;
5509 vehicle_controls = controls;
5510 }
5511 }
5512 }
5513 if( num_valid_controls < 1 ) {
5514 add_msg( _( "No vehicle controls found." ) );
5515 return;
5516 } else if( num_valid_controls > 1 ) {
5517 vehicle_position = choose_adjacent( _( "Control vehicle where?" ) );
5518 if( !vehicle_position ) {
5519 return;
5520 }
5521 const optional_vpart_position vp = m.veh_at( *vehicle_position );
5522 if( vp ) {
5523 vehicle_controls = vp.value().part_with_feature( "CONTROLS", true );
5524 if( !vehicle_controls ) {
5525 add_msg( _( "The vehicle doesn't have controls there." ) );
5526 return;
5527 }
5528 } else {
5529 add_msg( _( "No vehicle there." ) );
5530 return;
5531 }
5532 }
5533 // If we hit neither of those, there's only one set of vehicle controls, which should already have been found.
5534 if( vehicle_controls ) {
5535 veh = &vehicle_controls->vehicle();
5536 if( !veh->handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
5537 return;
5538 }
5539 veh->use_controls( *vehicle_position );
5540 //May be folded up (destroyed), so need to re-get it
5541 veh = g->remoteveh();
5542 }
5543 }
5544 if( veh ) {
5545 // If we reached here, we gained control of a vehicle.
5546 // Clear the map memory for the area covered by the vehicle to eliminate ghost vehicles.
5547 for( const tripoint &target : veh->get_points() ) {
5548 u.clear_memorized_tile( m.getabs( target ) );
5549 }
5550 veh->is_following = false;
5551 veh->is_patrolling = false;
5552 veh->autopilot_on = false;
5553 veh->is_autodriving = false;
5554 }
5555}
cata::optional< tripoint > choose_adjacent(const std::string &message, const bool allow_vertical)
Request player input of adjacent tile, possibly including vertical tiles.
Definition: action.cpp:1013
bool in_vehicle
Definition: character.h:1519
void clear_memorized_tile(const tripoint &pos)
Definition: avatar.cpp:165
vehicle * remoteveh()
Returns the current remotely controlled vehicle.
Definition: game.cpp:2574
tripoint_range< tripoint > points_in_radius(const tripoint &center, size_t radius, size_t radiusz=0) const
Definition: map.cpp:8422
optional_vpart_position veh_at(const tripoint &p) const
Checks if tile is occupied by vehicle and by which part.
Definition: map.cpp:1004
Simple wrapper to forward functions that may return a cata::optional to vpart_position.
Definition: player.h:90
bool engine_on
Definition: vehicle.h:1969
std::set< tripoint > & get_points(bool force_refresh=false)
Definition: vehicle.cpp:6581
bool handle_potential_theft(player &p, bool check_only=false, bool prompt=true)
Definition: vehicle.cpp:4200
std::string name
Definition: vehicle.h:1829
bool has_engine_type(const itype_id &ft, bool enabled) const
Definition: vehicle.cpp:1031
void start_engines(bool take_control=false, bool autodrive=false)
void use_controls(const tripoint &pos)
Operate vehicle controls.
vehicle(const vproto_id &type_id, int init_veh_fuel=-1, int init_veh_status=-1)
Definition: vehicle.cpp:251
bool has_harnessed_animal() const
bool interact_vehicle_locked()
int avail_part_with_feature(int p, const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2545
bool autopilot_on
Definition: vehicle.h:1977
bool is_autodriving
Definition: vehicle.h:1962
cata::optional< vpart_reference > part_with_feature(const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2461
static const trait_id trait_WAYFARER("WAYFARER")

References _, add_msg(), vehicle::autopilot_on, vehicle::avail_part_with_feature(), choose_adjacent(), avatar::clear_memorized_tile(), Character::controlling_vehicle, vehicle::engine_on, fuel_type_animal, g, vehicle::get_points(), map::getabs(), vehicle::handle_potential_theft(), vehicle::has_engine_type(), vehicle::has_harnessed_animal(), Character::has_trait(), Character::in_vehicle, vehicle::interact_vehicle_locked(), vehicle::is_autodriving, vehicle::is_following, vehicle::is_patrolling, m, m_info, vehicle::name, vpart_position::part_with_feature(), vehicle::player_in_control(), map::points_in_radius(), Character::pos(), remoteveh(), vehicle::start_engines(), trait_WAYFARER, u, vehicle::use_controls(), cata::optional< T >::value(), map::veh_at(), and vehicle::vehicle().

Referenced by handle_action().

◆ create_or_get_main_ui_adaptor()

shared_ptr_fast< ui_adaptor > game::create_or_get_main_ui_adaptor ( )

In tiles mode w_terrain can have a different font (with a different tile dimension) or can be drawn by cata_tiles which uses tiles that again might have a different dimension then the normal font used everywhere else.

TERRAIN_WINDOW_WIDTH/TERRAIN_WINDOW_HEIGHT defines how many squares can be displayed in w_terrain (using it's specific tile dimension), not including partially drawn squares at the right/bottom. You should use it whenever you want to draw specific squares in that window or to determine whether a specific square is draw on screen (or outside the screen and needs scrolling).

TERRAIN_WINDOW_TERM_WIDTH/TERRAIN_WINDOW_TERM_HEIGHT defines the size of w_terrain in the standard font dimension (the font that everything else uses). You usually don't have to use it, expect for positioning of windows, because the window positions use the standard font dimension.

The code here calculates size available for w_terrain, caps it at max_view_size (the maximal view range than any character can have at any time). It is stored in TERRAIN_WINDOW_*.

Definition at line 3288 of file game.cpp.

3289{
3291 if( !ui ) {
3292 main_ui_adaptor = ui = make_shared_fast<ui_adaptor>();
3293 ui->on_redraw( []( const ui_adaptor & ) {
3294 g->draw();
3295 } );
3296 ui->on_screen_resize( [this]( ui_adaptor & ui ) {
3297 // remove some space for the sidebar, this is the maximal space
3298 // (using standard font) that the terrain window can have
3299 const int sidebar_left = panel_manager::get_manager().get_width_left();
3300 const int sidebar_right = panel_manager::get_manager().get_width_right();
3301
3303 TERRAIN_WINDOW_WIDTH = TERMX - ( sidebar_left + sidebar_right );
3306
3307 /**
3308 * In tiles mode w_terrain can have a different font (with a different
3309 * tile dimension) or can be drawn by cata_tiles which uses tiles that again
3310 * might have a different dimension then the normal font used everywhere else.
3311 *
3312 * TERRAIN_WINDOW_WIDTH/TERRAIN_WINDOW_HEIGHT defines how many squares can
3313 * be displayed in w_terrain (using it's specific tile dimension), not
3314 * including partially drawn squares at the right/bottom. You should
3315 * use it whenever you want to draw specific squares in that window or to
3316 * determine whether a specific square is draw on screen (or outside the screen
3317 * and needs scrolling).
3318 *
3319 * TERRAIN_WINDOW_TERM_WIDTH/TERRAIN_WINDOW_TERM_HEIGHT defines the size of
3320 * w_terrain in the standard font dimension (the font that everything else uses).
3321 * You usually don't have to use it, expect for positioning of windows,
3322 * because the window positions use the standard font dimension.
3323 *
3324 * The code here calculates size available for w_terrain, caps it at
3325 * max_view_size (the maximal view range than any character can have at
3326 * any time).
3327 * It is stored in TERRAIN_WINDOW_*.
3328 */
3330
3331 // Position of the player in the terrain window, it is always in the center
3334
3336 point( sidebar_left, 0 ) );
3337
3338 // minimap is always MINIMAP_WIDTH x MINIMAP_HEIGHT in size
3340
3341 // need to init in order to avoid crash. gets updated by the panel code.
3343
3344 ui.position_from_window( catacurses::stdscr );
3345 } );
3346 ui->mark_resize();
3347 }
3348 return ui;
3349}
catacurses::window w_pixel_minimap
Definition: game.h:1039
catacurses::window w_minimap_ptr
Definition: game.h:1076
weak_ptr_fast< ui_adaptor > main_ui_adaptor
Definition: game.h:1122
catacurses::window w_minimap
Definition: game.h:1038
catacurses::window w_terrain_ptr
Definition: game.h:1075
static panel_manager & get_manager()
Definition: panels.h:72
int get_width_right()
Definition: panels.cpp:2293
int get_width_left()
Definition: panels.cpp:2301
static constexpr int MINIMAP_WIDTH
static constexpr int MINIMAP_HEIGHT
void to_map_font_dimension(int &, int &)
Definition: game_ui.cpp:20
std::shared_ptr< T > shared_ptr_fast
Definition: memory_fast.h:16
window stdscr
int TERRAIN_WINDOW_TERM_WIDTH
Definition: output.cpp:53
int TERRAIN_WINDOW_TERM_HEIGHT
Definition: output.cpp:54
int POSX
Definition: output.cpp:49
int TERRAIN_WINDOW_WIDTH
Definition: output.cpp:51
int POSY
Definition: output.cpp:50
int TERRAIN_WINDOW_HEIGHT
Definition: output.cpp:52

References g, panel_manager::get_manager(), panel_manager::get_width_left(), panel_manager::get_width_right(), main_ui_adaptor, MINIMAP_HEIGHT, MINIMAP_WIDTH, catacurses::newwin(), point_zero, POSX, POSY, catacurses::stdscr, TERMX, TERMY, TERRAIN_WINDOW_HEIGHT, TERRAIN_WINDOW_TERM_HEIGHT, TERRAIN_WINDOW_TERM_WIDTH, TERRAIN_WINDOW_WIDTH, to_map_font_dimension(), w_minimap, w_minimap_ptr, w_pixel_minimap, w_terrain, and w_terrain_ptr.

◆ create_starting_npcs()

void game::create_starting_npcs ( )
private

Definition at line 973 of file game.cpp.

974{
975 if( !get_option<bool>( "STATIC_NPC" ) ||
976 get_option<std::string>( "STARTING_NPC" ) == "never" ) {
977 return; //Do not generate a starting npc.
978 }
979
980 //We don't want more than one starting npc per starting location
981 const int radius = 1;
982 if( !overmap_buffer.get_npcs_near_player( radius ).empty() ) {
983 return; //There is already an NPC in this starting location
984 }
985
986 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
987 tmp->normalize();
988 tmp->randomize( one_in( 2 ) ? NC_DOCTOR : NC_NONE );
989 tmp->spawn_at_precise( { get_levx(), get_levy() }, u.pos() - point_south_east );
991 tmp->form_opinion( u );
992 tmp->set_attitude( NPCATT_NULL );
993 //This sets the NPC mission. This NPC remains in the starting location.
994 tmp->mission = NPC_MISSION_SHELTER;
995 tmp->chatbin.first_topic = "TALK_SHELTER";
996 tmp->toggle_trait( trait_id( "NPC_STARTING_NPC" ) );
997 tmp->set_fac( faction_id( "no_faction" ) );
998 //One random starting NPC mission
999 tmp->add_new_mission( mission::reserve_random( ORIGIN_OPENER_NPC, tmp->global_omt_location(),
1000 tmp->getID() ) );
1001}
int get_levy() const
Definition: game.cpp:12409
int get_levx() const
The top left corner of the reality bubble (in submaps coordinates).
Definition: game.cpp:12404
static mission * reserve_random(mission_origin origin, const tripoint_abs_omt &p, const character_id &npc_id)
Definition: mission.cpp:200
std::vector< shared_ptr_fast< npc > > get_npcs_near_player(int radius)
Same as get_npcs_near(int,int,int,int) but uses player position as center.
void insert_npc(const shared_ptr_fast< npc > &who)
Adds the npc to an overmap ( based on the npcs current location ) and stores it there.
string_id< faction > faction_id
Definition: clzones.h:30
@ ORIGIN_OPENER_NPC
Definition: mission.h:45
@ NPCATT_NULL
Definition: npc.h:81
@ NPC_MISSION_SHELTER
Definition: npc.h:181
npc_class_id NC_NONE("NC_NONE")
npc_class_id NC_DOCTOR("NC_DOCTOR")
static constexpr point point_south_east
Definition: point.h:279
bool one_in(int chance)
Definition: rng.cpp:65

References get_levx(), get_levy(), overmapbuffer::get_npcs_near_player(), overmapbuffer::insert_npc(), NC_DOCTOR, NC_NONE, NPC_MISSION_SHELTER, NPCATT_NULL, one_in(), ORIGIN_OPENER_NPC, overmap_buffer, point_south_east, Character::pos(), mission::reserve_random(), trait_id, and u.

Referenced by start_game().

◆ critter_at() [1/2]

template<typename T >
T * game::critter_at ( const tripoint p,
bool  allow_hallucination = false 
)

Returns the Creature at the given location.

Optionally casted to the given type of creature: npc, player, monster - if there is a creature, but it's not of the requested type, returns nullptr.

Parameters
allow_hallucinationWhether to return monsters that are actually hallucinations.

Definition at line 4848 of file game.cpp.

4849{
4850 if( const shared_ptr_fast<monster> mon_ptr = critter_tracker->find( p ) ) {
4851 if( !allow_hallucination && mon_ptr->is_hallucination() ) {
4852 return nullptr;
4853 }
4854 // if we wanted to check for an NPC / player / avatar,
4855 // there is sometimes a monster AND an NPC/player there at the same time.
4856 // because the NPC/player etc may be riding that monster.
4857 // so only return the monster if we were actually looking for a monster.
4858 // otherwise, keep looking for the rider.
4859 // critter_at<creature> or critter_at() with no template will still default to returning monster first,
4860 // which is ok for the occasions where that happens.
4861 if( !mon_ptr->has_effect( effect_ridden ) || ( std::is_same<T, monster>::value ||
4862 std::is_same<T, Creature>::value || std::is_same<T, const monster>::value ||
4863 std::is_same<T, const Creature>::value ) ) {
4864 return dynamic_cast<T *>( mon_ptr.get() );
4865 }
4866 }
4867 if( !std::is_same<T, npc>::value && !std::is_same<T, const npc>::value ) {
4868 if( p == u.pos() ) {
4869 return dynamic_cast<T *>( &u );
4870 }
4871 }
4872 for( auto &cur_npc : active_npc ) {
4873 if( cur_npc->pos() == p && !cur_npc->is_dead() ) {
4874 return dynamic_cast<T *>( cur_npc.get() );
4875 }
4876 }
4877 return nullptr;
4878}
static const efftype_id effect_ridden("ridden")

References active_npc, critter_tracker, effect_ridden, Character::pos(), and u.

Referenced by draw_look_around_cursor(), examine(), find_or_make_stairs(), fling_creature(), forced_door_closing(), get_player_input(), is_empty(), knockback(), phasing_move(), print_all_tile_info(), spawn_hallucination(), swap_critters(), and update_stair_monsters().

◆ critter_at() [2/2]

template<typename T >
const T * game::critter_at ( const tripoint p,
bool  allow_hallucination = false 
) const

Definition at line 4881 of file game.cpp.

4882{
4883 return const_cast<game *>( this )->critter_at<T>( p, allow_hallucination );
4884}
Definition: game.h:144

◆ critter_by_id()

template<typename T >
template Creature * game::critter_by_id< Creature > ( const character_id id)
Returns
The living creature with the given id. Returns null if no living creature with such an id exists. Never returns a dead creature. Currently only the player character and npcs have ids.

Definition at line 4927 of file game.cpp.

4928{
4929 if( id == u.getID() ) {
4930 // player is always alive, therefore no is-dead check
4931 return dynamic_cast<T *>( &u );
4932 }
4933 return find_npc( id );
4934}
character_id getID() const
Definition: character.cpp:477
npc * find_npc(character_id id)
Find the npc with the given ID.
Definition: game.cpp:1955

References find_npc(), Character::getID(), and u.

◆ death_screen()

void game::death_screen ( )
private

Definition at line 2738 of file game.cpp.

2739{
2740 gamemode->game_over();
2744 follower_ids.clear();
2746}
stats_tracker & stats()
Definition: game.cpp:3096
void disp_NPC_epilogues()
Definition: game.cpp:3175
void display_faction_epilogues()
Definition: game.cpp:3192
void display_messages()
Definition: messages.cpp:801
void show_scores_ui(const achievements_tracker &achievements, stats_tracker &stats, const kill_tracker &kills)
Definition: scores_ui.cpp:69

References achievements_tracker_ptr, disp_NPC_epilogues(), display_faction_epilogues(), Messages::display_messages(), follower_ids, gamemode, get_kill_tracker(), show_scores_ui(), and stats().

Referenced by cleanup_at_end().

◆ despawn_monster()

void game::despawn_monster ( monster critter)

Despawn a specific monster, it's stored on the overmap.

Also removes it from the creature tracker. Keep in mind that any monster index may point to a different monster after calling this (or to no monster at all).

Definition at line 11544 of file game.cpp.

11545{
11546 if( !critter.is_hallucination() ) {
11547 // hallucinations aren't stored, they come and go as they like,
11549 }
11550
11551 critter.on_unload();
11552 remove_zombie( critter );
11553 // simulate it being dead so further processing of it (e.g. in monmove) will yield
11554 critter.set_hp( 0 );
11555}
void remove_zombie(const monster &critter)
Definition: game.cpp:5038
bool is_hallucination() const override
Definition: monster.cpp:2648
void on_unload()
Do some cleanup and caching as monster is being unloaded from map.
Definition: monster.cpp:2980
void set_hp(int hp)
Directly set the current hp of the monster (not capped at the maximal hp).
Definition: monster.cpp:1631
void despawn_monster(const monster &critter)
Despawn the monster back onto the overmap.

References overmapbuffer::despawn_monster(), monster::is_hallucination(), monster::on_unload(), overmap_buffer, remove_zombie(), and monster::set_hp().

Referenced by cleanup_at_end(), monmove(), place_player_overmap(), and shift_monsters().

◆ disable_robot()

bool game::disable_robot ( const tripoint p)

If there is a robot (that can be disabled), query the player and try to disable it.

Returns
true if the robot has been disabled or a similar action has been done. false if the player did not choose any action and the function has effectively done nothing.

Definition at line 9190 of file game.cpp.

9191{
9192 monster *const mon_ptr = critter_at<monster>( p );
9193 if( !mon_ptr ) {
9194 return false;
9195 }
9196 monster &critter = *mon_ptr;
9197 if( critter.friendly == 0 || critter.has_flag( MF_RIDEABLE_MECH ) ||
9198 ( critter.has_flag( MF_PAY_BOT ) && critter.has_effect( effect_paid ) ) ) {
9199 // Can only disable / reprogram friendly monsters
9200 return false;
9201 }
9202 const auto mid = critter.type->id;
9203 const auto mon_item_id = critter.type->revert_to_itype;
9204 if( !mon_item_id.is_empty() &&
9205 query_yn( _( "Deactivate the %s?" ), critter.name() ) ) {
9206
9207 u.moves -= 100;
9208 m.add_item_or_charges( p, critter.to_item() );
9209 if( !critter.has_flag( MF_INTERIOR_AMMO ) ) {
9210 for( auto &ammodef : critter.ammo ) {
9211 if( ammodef.second > 0 ) {
9212 m.spawn_item( p.xy(), ammodef.first, 1, ammodef.second, calendar::turn );
9213 }
9214 }
9215 }
9216 remove_zombie( critter );
9217 return true;
9218 }
9219 // Manhacks are special, they have their own menu here.
9220 if( mid == mon_manhack ) {
9221 int choice = UILIST_CANCEL;
9222 if( critter.has_effect( effect_docile ) ) {
9223 choice = uilist( _( "Reprogram the manhack?" ), { _( "Engage targets." ) } );
9224 } else {
9225 choice = uilist( _( "Reprogram the manhack?" ), { _( "Follow me." ) } );
9226 }
9227 switch( choice ) {
9228 case 0:
9229 if( critter.has_effect( effect_docile ) ) {
9230 critter.remove_effect( effect_docile );
9231 if( one_in( 3 ) ) {
9232 add_msg( _( "The %s hovers momentarily as it surveys the area." ),
9233 critter.name() );
9234 }
9235 } else {
9236 critter.add_effect( effect_docile, 1_turns, num_bp );
9237 if( one_in( 3 ) ) {
9238 add_msg( _( "The %s lets out a whirring noise and starts to follow you." ),
9239 critter.name() );
9240 }
9241 }
9242 u.moves -= 100;
9243 return true;
9244 default:
9245 break;
9246 }
9247 }
9248 return false;
9249}
@ num_bp
Definition: bodypart.h:52
bool remove_effect(const efftype_id &eff_id, body_part bp=num_bp)
Removes a listed effect.
Definition: creature.cpp:1133
void spawn_item(const tripoint &p, const itype_id &type_id, unsigned quantity=1, int charges=0, const time_point &birthday=calendar::start_of_cataclysm, int damlevel=0)
Definition: map.cpp:4173
bool has_flag(m_flag f) const override
Definition: monster.cpp:869
item to_item() const
Convert this monster into an item (see mtype::revert_to_itype).
Definition: monster.cpp:2788
void add_effect(const efftype_id &eff_id, const time_duration &dur, const bodypart_str_id &bp, int intensity=0, bool force=false, bool deferred=false) override
Performs any monster-specific modifications to the arguments before passing to Creature::add_effect()...
Definition: monster.cpp:1807
int friendly
Definition: monster.h:471
std::string name(unsigned int quantity=1) const
Definition: monster.cpp:492
std::map< itype_id, int > ammo
Definition: monster.h:512
static const efftype_id effect_docile("docile")
static const efftype_id effect_paid("paid")
static const mtype_id mon_manhack("mon_manhack")
@ MF_INTERIOR_AMMO
Definition: mtype.h:146
@ MF_RIDEABLE_MECH
Definition: mtype.h:115
@ MF_PAY_BOT
Definition: mtype.h:121
itype_id revert_to_itype
If this is not empty, the monster can be converted into an item of this type (if it's friendly).
Definition: mtype.h:361
constexpr point xy() const
Definition: point.h:220
const int UILIST_CANCEL
Definition: ui.h:28

References _, monster::add_effect(), map::add_item_or_charges(), add_msg(), monster::ammo, effect_docile, effect_paid, monster::friendly, Creature::has_effect(), monster::has_flag(), mtype::id, m, MF_INTERIOR_AMMO, MF_PAY_BOT, MF_RIDEABLE_MECH, mon_manhack, Creature::moves, monster::name(), num_bp, one_in(), query_yn(), Creature::remove_effect(), remove_zombie(), mtype::revert_to_itype, map::spawn_item(), monster::to_item(), calendar::turn, monster::type, u, UILIST_CANCEL, and tripoint::xy().

Referenced by examine().

◆ disp_NPC_epilogues()

void game::disp_NPC_epilogues ( )
private

Definition at line 3175 of file game.cpp.

3176{
3177 // TODO: This search needs to be expanded to all NPCs
3178 for( auto elem : follower_ids ) {
3180 if( !guy ) {
3181 continue;
3182 }
3183 const auto new_win = []() {
3185 point( std::max( 0, ( TERMX - FULL_SCREEN_WIDTH ) / 2 ),
3186 std::max( 0, ( TERMY - FULL_SCREEN_HEIGHT ) / 2 ) ) );
3187 };
3188 scrollable_text( new_win, guy->disp_name(), guy->get_epilogue() );
3189 }
3190}
shared_ptr_fast< npc > find_npc(character_id id)
Find the npc with the given ID.
void scrollable_text(const std::function< catacurses::window()> &init_window, const std::string &title, const std::string &text)
Definition: output.cpp:352

References overmapbuffer::find_npc(), follower_ids, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, catacurses::newwin(), overmap_buffer, scrollable_text(), TERMX, and TERMY.

Referenced by death_screen().

◆ disp_NPCs()

void game::disp_NPCs ( )

Definition at line 3226 of file game.cpp.

3227{
3228 const tripoint_abs_omt ppos = u.global_omt_location();
3229 const tripoint &lpos = u.pos();
3230 std::vector<shared_ptr_fast<npc>> npcs = overmap_buffer.get_npcs_near_player( 100 );
3231 std::sort( npcs.begin(), npcs.end(), npc_dist_to_player() );
3232
3234 ui_adaptor ui;
3235 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
3238 TERMY > FULL_SCREEN_HEIGHT ? ( TERMY - FULL_SCREEN_HEIGHT ) / 2 : 0 ) );
3239 ui.position_from_window( w );
3240 } );
3241 ui.mark_resize();
3242 ui.on_redraw( [&]( const ui_adaptor & ) {
3243 werase( w );
3244 mvwprintz( w, point_zero, c_white, _( "Your overmap position: %s" ), ppos.to_string() );
3245 // NOLINTNEXTLINE(cata-use-named-point-constants)
3246 mvwprintz( w, point( 0, 1 ), c_white, _( "Your local position: %s" ), lpos.to_string() );
3247 size_t i;
3248 for( i = 0; i < 20 && i < npcs.size(); i++ ) {
3249 const tripoint_abs_omt apos = npcs[i]->global_omt_location();
3250 mvwprintz( w, point( 0, i + 3 ), c_white, "%s: %s", npcs[i]->name,
3251 apos.to_string() );
3252 }
3253 for( const monster &m : all_monsters() ) {
3254 mvwprintz( w, point( 0, i + 3 ), c_white, "%s: %d, %d, %d", m.name(),
3255 m.posx(), m.posy(), m.posz() );
3256 ++i;
3257 }
3258 wnoutrefresh( w );
3259 } );
3260
3261 input_context ctxt( "DISP_NPCS" );
3262 ctxt.register_action( "CONFIRM" );
3263 ctxt.register_action( "QUIT" );
3264 ctxt.register_action( "HELP_KEYBINDINGS" );
3265 bool stop = false;
3266 while( !stop ) {
3268 const std::string action = ctxt.handle_input();
3269 if( action == "CONFIRM" || action == "QUIT" ) {
3270 stop = true;
3271 }
3272 }
3273}
tripoint_abs_omt global_omt_location() const
Returns the location of the player in global overmap terrain coordinates.
Definition: character.cpp:6351
std::string to_string() const
Definition: coordinates.h:140
Represents a context in which a set of actions can be performed.
Definition: input.h:382
std::string name(const tripoint &p)
Definition: map.cpp:1320
void wnoutrefresh(const window &win)
Definition: ncurses_def.cpp:43
void werase(const window &win)
Definition: ncurses_def.cpp:53
std::string to_string() const
Definition: point.cpp:16

References _, action, all_monsters(), c_white, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, overmapbuffer::get_npcs_near_player(), Character::global_omt_location(), input_context::handle_input(), m, mvwprintz(), map::name(), om_direction::name(), catacurses::newwin(), overmap_buffer, point_zero, Character::pos(), ui_manager::redraw(), input_context::register_action(), TERMX, TERMY, coords::coord_point< Point, Origin, Scale >::to_string(), tripoint::to_string(), u, catacurses::werase(), and catacurses::wnoutrefresh().

◆ display_faction_epilogues()

void game::display_faction_epilogues ( )
private

Definition at line 3192 of file game.cpp.

3193{
3194 for( const auto &elem : faction_manager_ptr->all() ) {
3195 if( elem.second.known_by_u ) {
3196 const std::vector<std::string> epilogue = elem.second.epilogue();
3197 if( !epilogue.empty() ) {
3198 const auto new_win = []() {
3200 point( std::max( 0, ( TERMX - FULL_SCREEN_WIDTH ) / 2 ),
3201 std::max( 0, ( TERMY - FULL_SCREEN_HEIGHT ) / 2 ) ) );
3202 };
3203 scrollable_text( new_win, elem.second.name,
3204 std::accumulate( epilogue.begin() + 1, epilogue.end(), epilogue.front(),
3205 []( const std::string & lhs, const std::string & rhs ) -> std::string {
3206 return lhs + "\n" + rhs;
3207 } ) );
3208 }
3209 }
3210 }
3211}
pimpl< faction_manager > faction_manager_ptr
Definition: game.h:1022

References faction_manager_ptr, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, catacurses::newwin(), scrollable_text(), TERMX, and TERMY.

Referenced by death_screen().

◆ display_lighting()

void game::display_lighting ( )
private

Definition at line 11756 of file game.cpp.

11757{
11758 if( use_tiles ) {
11760 if( !g->display_overlay_state( ACTION_DISPLAY_LIGHTING ) ) {
11761 return;
11762 }
11763 uilist lighting_menu;
11764 std::vector<std::string> lighting_menu_strings{
11765 "Global lighting conditions"
11766 };
11767
11768 int count = 0;
11769 for( const auto &menu_str : lighting_menu_strings ) {
11770 lighting_menu.addentry( count++, true, MENU_AUTOASSIGN, "%s", menu_str );
11771 }
11772
11773 lighting_menu.w_y_setup = 0;
11774 lighting_menu.query();
11775 if( ( lighting_menu.ret >= 0 ) &&
11776 ( static_cast<size_t>( lighting_menu.ret ) < lighting_menu_strings.size() ) ) {
11777 g->displaying_lighting_condition = lighting_menu.ret;
11778 }
11779 }
11780}
@ ACTION_DISPLAY_LIGHTING
Toggle lighting conditions map.
Definition: action.h:317
bool use_tiles
Use tiles for display.
void display_toggle_overlay(action_id)
Definition: game.cpp:11652
pos_scalar w_y_setup
Definition: ui.h:338
constexpr size_t count()
Definition: fmtlib_core.h:1073
const int MENU_AUTOASSIGN
Definition: ui.h:31

References ACTION_DISPLAY_LIGHTING, uilist::addentry(), detail::count(), display_toggle_overlay(), g, MENU_AUTOASSIGN, uilist::query(), uilist::ret, use_tiles, and uilist::w_y_setup.

Referenced by handle_action(), and look_around().

◆ display_overlay_state()

bool game::display_overlay_state ( action_id  action)

Definition at line 11647 of file game.cpp.

11648{
11650}
cata::optional< action_id > displaying_overlays
Definition: game.h:967

References action, and displaying_overlays.

Referenced by display_toggle_overlay(), and display_visibility().

◆ display_radiation()

void game::display_radiation ( )
private

Definition at line 11782 of file game.cpp.

11783{
11784 if( use_tiles ) {
11786 }
11787}
@ ACTION_DISPLAY_RADIATION
Toggle radiation map.
Definition: action.h:319

References ACTION_DISPLAY_RADIATION, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_scent()

void game::display_scent ( )
private

Definition at line 11661 of file game.cpp.

11662{
11663 if( use_tiles ) {
11665 } else {
11666 int div;
11667 bool got_value = query_int( div, _( "Set the Scent Map sensitivity to (0 to cancel)?" ) );
11668 if( !got_value || div < 1 ) {
11669 add_msg( _( "Never mind." ) );
11670 return;
11671 }
11672 shared_ptr_fast<game::draw_callback_t> scent_cb = make_shared_fast<game::draw_callback_t>( [&]() {
11673 scent.draw( w_terrain, div * 2, u.pos() + u.view_offset );
11674 } );
11675 g->add_draw_callback( scent_cb );
11676
11679 }
11680}
@ ACTION_DISPLAY_SCENT
Toggle scent map.
Definition: action.h:279
void wait_for_any_key()
Wait until the user presses a key.
Definition: input.cpp:1309
tripoint view_offset
Definition: player.h:639
void draw(const catacurses::window &win, int div, const tripoint &center) const
Definition: scent_map.cpp:70
input_manager inp_mngr
Definition: input.cpp:109
bool query_int(int &result, int default_val, const std::string &text)
Definition: output.cpp:718

References _, ACTION_DISPLAY_SCENT, add_msg(), display_toggle_overlay(), scent_map::draw(), g, inp_mngr, Character::pos(), query_int(), ui_manager::redraw(), scent, u, use_tiles, player::view_offset, w_terrain, and input_manager::wait_for_any_key().

Referenced by handle_action(), and look_around().

◆ display_temperature()

void game::display_temperature ( )
private

Definition at line 11682 of file game.cpp.

11683{
11684 if( use_tiles ) {
11686 }
11687}
@ ACTION_DISPLAY_TEMPERATURE
Toggle temperature map.
Definition: action.h:311

References ACTION_DISPLAY_TEMPERATURE, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_toggle_overlay()

void game::display_toggle_overlay ( action_id  action)

Definition at line 11652 of file game.cpp.

11653{
11654 if( display_overlay_state( action ) ) {
11655 displaying_overlays.reset();
11656 } else {
11658 }
11659}
bool display_overlay_state(action_id)
Definition: game.cpp:11647

References action, display_overlay_state(), and displaying_overlays.

Referenced by display_lighting(), display_radiation(), display_scent(), display_temperature(), display_transparency(), display_vehicle_ai(), and display_visibility().

◆ display_transparency()

void game::display_transparency ( )
private

Definition at line 11789 of file game.cpp.

11790{
11791 if( use_tiles ) {
11793 }
11794}
@ ACTION_DISPLAY_TRANSPARENCY
Toggle transparency map.
Definition: action.h:321

References ACTION_DISPLAY_TRANSPARENCY, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_vehicle_ai()

void game::display_vehicle_ai ( )
private

Definition at line 11689 of file game.cpp.

11690{
11691 if( use_tiles ) {
11693 }
11694}
@ ACTION_DISPLAY_VEHICLE_AI
Toggle vehicle autopilot data.
Definition: action.h:313

References ACTION_DISPLAY_VEHICLE_AI, display_toggle_overlay(), and use_tiles.

Referenced by handle_action().

◆ display_visibility()

void game::display_visibility ( )
private

Definition at line 11696 of file game.cpp.

11697{
11698 if( use_tiles ) {
11701 std::vector< tripoint > locations;
11702 uilist creature_menu;
11703 int num_creatures = 0;
11704 creature_menu.addentry( num_creatures++, true, MENU_AUTOASSIGN, "%s", _( "You" ) );
11705 locations.emplace_back( g->u.pos() ); // add player first.
11706 for( const Creature &critter : g->all_creatures() ) {
11707 if( critter.is_player() ) {
11708 continue;
11709 }
11710 creature_menu.addentry( num_creatures++, true, MENU_AUTOASSIGN, critter.disp_name() );
11711 locations.emplace_back( critter.pos() );
11712 }
11713
11714 pointmenu_cb callback( locations );
11715 creature_menu.callback = &callback;
11716 creature_menu.w_y_setup = 0;
11717 creature_menu.query();
11718 if( creature_menu.ret >= 0 && static_cast<size_t>( creature_menu.ret ) < locations.size() ) {
11719 Creature *creature = critter_at<Creature>( locations[creature_menu.ret] );
11721 }
11722 } else {
11724 }
11725 }
11726}
@ ACTION_DISPLAY_VISIBILITY
Toggle visibility map.
Definition: action.h:315
size_t num_creatures() const
Returns the approximate number of creatures in the reality bubble.
Definition: game.cpp:5028
Creature * displaying_visibility_creature
Creature for which to display the visibility map.
Definition: game.h:1058
Callback for uilist that pairs menu entries with points When an entry is selected,...
Definition: ui.h:423
uilist_callback * callback
Definition: ui.h:335
generic_factory< overmap_location > locations("overmap location")

References _, ACTION_DISPLAY_VISIBILITY, uilist::addentry(), uilist::callback, creature, display_overlay_state(), display_toggle_overlay(), displaying_visibility_creature, g, anonymous_namespace{overmap_location.cpp}::locations, MENU_AUTOASSIGN, num_creatures(), uilist::query(), uilist::ret, use_tiles, and uilist::w_y_setup.

Referenced by handle_action().

◆ do_turn()

bool game::do_turn ( )

MAIN GAME LOOP.

Returns true if game is over (death, saved, quit, etc.).

Definition at line 1436 of file game.cpp.

1437{
1438 if( is_game_over() ) {
1439 return cleanup_at_end();
1440 }
1441 // Actual stuff
1442 if( new_game ) {
1443 new_game = false;
1444 } else {
1445 gamemode->per_turn();
1446 calendar::turn += 1_turns;
1447 }
1448
1449 // starting a new turn, clear out temperature cache
1451 weather.clear_temp_cache();
1452
1453 if( npcs_dirty ) {
1454 load_npcs();
1455 }
1456
1459 // If controlling a vehicle that is owned by someone else
1461 vehicle *veh = veh_pointer_or_null( m.veh_at( u.pos() ) );
1462 if( veh && !veh->handle_potential_theft( dynamic_cast<player &>( u ), true ) ) {
1463 veh->handle_potential_theft( dynamic_cast<player &>( u ), false, false );
1464 }
1465 }
1466 // If riding a horse - chance to spook
1467 if( u.is_mounted() ) {
1469 }
1470 if( calendar::once_every( 1_days ) ) {
1472 }
1473
1474 // Move hordes every 2.5 min
1477 // Hordes that reached the reality bubble need to spawn,
1478 // make them spawn in invisible areas only.
1479 m.spawn_monsters( false );
1480 }
1481
1483
1484 u.update_body();
1485
1486 // Auto-save if autosave is enabled
1487 if( get_option<bool>( "AUTOSAVE" ) &&
1488 calendar::once_every( 1_turns * get_option<int>( "AUTOSAVE_TURNS" ) ) &&
1489 !u.is_dead_state() ) {
1490 autosave();
1491 }
1492
1493 weather.update_weather();
1495
1499 // Process NPC sound events before they move or they hear themselves talking
1500 for( npc &guy : all_npcs() ) {
1501 if( rl_dist( guy.pos(), u.pos() ) < MAX_VIEW_DISTANCE ) {
1503 }
1504 }
1505
1506 // Process sound events into sound markers for display to the player.
1508
1509 if( u.is_deaf() ) {
1511 }
1512
1513 if( !u.has_effect( effect_sleep ) || uquit == QUIT_WATCH ) {
1514 if( u.moves > 0 || uquit == QUIT_WATCH ) {
1515 while( u.moves > 0 || uquit == QUIT_WATCH ) {
1516 cleanup_dead();
1518 // Process any new sounds the player caused during their turn.
1519 for( npc &guy : all_npcs() ) {
1520 if( rl_dist( guy.pos(), u.pos() ) < MAX_VIEW_DISTANCE ) {
1522 }
1523 }
1526 wait_popup.reset();
1528 }
1529
1530 if( queue_screenshot ) {
1534 queue_screenshot = false;
1535 }
1536
1537 if( handle_action() ) {
1539 u.action_taken();
1540 }
1541
1542 if( is_game_over() ) {
1543 return cleanup_at_end();
1544 }
1545
1546 if( uquit == QUIT_WATCH ) {
1547 break;
1548 }
1549 if( u.activity ) {
1551 }
1552 }
1553 // Reset displayed sound markers now that the turn is over.
1554 // We only want this to happen if the player had a chance to examine the sounds.
1556 }
1557 }
1558
1559 if( driving_view_offset.x != 0 || driving_view_offset.y != 0 ) {
1560 // Still have a view offset, but might not be driving anymore,
1561 // or the option has been deactivated,
1562 // might also happen when someone dives from a moving car.
1563 // or when using the handbrake.
1564 vehicle *veh = veh_pointer_or_null( m.veh_at( u.pos() ) );
1565 calc_driving_offset( veh );
1566 }
1567
1568 // No-scent debug mutation has to be processed here or else it takes time to start working
1569 if( !u.has_active_bionic( bionic_id( "bio_scent_mask" ) ) &&
1570 !u.has_trait( trait_id( "DEBUG_NOSCENT" ) ) ) {
1573 }
1574 scent.update( u.pos(), m );
1575
1576 // We need floor cache before checking falling 'n stuff
1578
1581 m.vehmove();
1582 m.process_fields();
1583 m.process_items();
1586
1587 // Apply sounds from previous turn to monster and NPC AI.
1589 // Update vision caches for monsters. If this turns out to be expensive,
1590 // consider a stripped down cache just for monsters.
1591 m.build_map_cache( get_levz(), true );
1592 monmove();
1593 if( calendar::once_every( 5_minutes ) ) {
1595 }
1596 if( calendar::once_every( 10_seconds ) ) {
1597 for( const tripoint &elem : m.get_furn_field_locations() ) {
1598 const auto &furn = m.furn( elem ).obj();
1599 for( const emit_id &e : furn.emissions ) {
1600 m.emit_field( elem, e );
1601 }
1602 }
1603 }
1606 u.process_turn();
1607
1609 cleanup_dead();
1610
1611 if( u.moves < 0 && get_option<bool>( "FORCE_REDRAW" ) ) {
1614 }
1615
1616 if( get_levz() >= 0 && !u.is_underwater() ) {
1617 handle_weather_effects( weather.weather_id );
1618 }
1619
1620 const bool player_is_sleeping = u.has_effect( effect_sleep );
1621 bool wait_redraw = false;
1622 std::string wait_message;
1623 time_duration wait_refresh_rate;
1624 if( player_is_sleeping ) {
1625 wait_redraw = true;
1626 wait_message = _( "Wait till you wake up…" );
1627 wait_refresh_rate = 30_minutes;
1628 if( calendar::once_every( 1_hours ) ) {
1630 }
1631 } else if( u.has_destination() ) {
1632 wait_redraw = true;
1633 wait_message = _( "Travelling…" );
1634 wait_refresh_rate = 15_turns;
1635 } else if( const cata::optional<std::string> progress = u.activity.get_progress_message( u ) ) {
1636 wait_redraw = true;
1637 wait_message = *progress;
1638 if( u.activity.id() == ACT_AUTODRIVE ) {
1639 wait_refresh_rate = 1_turns;
1640 } else {
1641 wait_refresh_rate = 5_minutes;
1642 }
1643 }
1644 if( wait_redraw ) {
1646 calendar::once_every( std::min( 1_minutes, wait_refresh_rate ) ) ) {
1647 if( first_redraw_since_waiting_started || calendar::once_every( wait_refresh_rate ) ) {
1649 }
1650
1651 // Avoid redrawing the main UI every time due to invalidation
1653 wait_popup = std::make_unique<static_popup>();
1654 wait_popup->on_top( true ).wait_message( "%s", wait_message );
1658 }
1659 } else {
1660 // Nothing to wait for now
1661 wait_popup.reset();
1663 }
1664
1666 u.update_body_wetness( get_weather().get_precise() );
1667 u.apply_wetness_morale( weather.temperature );
1668
1669 if( calendar::once_every( 1_minutes ) ) {
1670 u.update_morale();
1671 }
1672
1673 if( calendar::once_every( 9_turns ) ) {
1675 }
1676
1677 if( !u.is_deaf() ) {
1679 }
1684
1685 // reset player noise
1686 u.volume = 0;
1687
1688 return false;
1689}
void update_morale()
Ticks down morale counters and removes them.
Definition: character.cpp:9014
void action_taken()
Called after every action, invalidates player caches.
Definition: character.cpp:877
bool check_mount_is_spooked()
Definition: character.cpp:1102
void update_bodytemp(const map &m, const weather_manager &weather)
Maintains body temperature.
Definition: character.cpp:5198
bool is_mounted() const
Definition: character.cpp:1143
bool has_destination() const
scenttype_id get_type_of_scent() const
Definition: character.cpp:8773
bool check_and_recover_morale()
Checks permanent morale for consistency and recovers it when an inconsistency is found.
Definition: character.cpp:9141
bool is_deaf() const
Definition: character.cpp:4502
void update_body()
Updates all "biology" by one turn.
Definition: character.cpp:4680
bool has_active_bionic(const bionic_id &b) const
Returns true if the player has the entered bionic id and it is powered on.
Definition: character.cpp:1890
void apply_wetness_morale(int temperature)
Recalculates morale penalty/bonus from wetness based on mutations, equipment and temperature.
Definition: suffer.cpp:1805
virtual bool is_underwater() const
Definition: creature.cpp:174
int get_levz() const
Definition: game.cpp:12414
void overmap_npc_move()
Definition: game.cpp:4537
class game::debug_hour_timer debug_hour_timer
npc_range all_npcs()
Same as all_creatures but iterators only over npcs.
Definition: game.cpp:12524
void monmove()
Definition: game.cpp:4412
void autopilot_vehicles()
process vehicles that are following the player
Definition: game.cpp:1753
void add_artifact_dreams()
Definition: game.cpp:12358
int moves_since_last_save
Definition: game.h:1088
bool take_screenshot() const
Saves a screenshot of the current viewport, as a PNG file.
Definition: game.cpp:7420
void calc_driving_offset(vehicle *veh=nullptr)
Definition: game.cpp:1334
bool cleanup_at_end()
Definition: game.cpp:1030
std::unique_ptr< static_popup > wait_popup
Definition: game.h:1124
bool queue_screenshot
Definition: game.h:1067
friend weather_manager & get_weather()
Definition: weather.cpp:64
void autosave()
Definition: game.cpp:11847
void process_activity()
Definition: game.cpp:1742
void update_stair_monsters()
Definition: game.cpp:11335
void process_voluntary_act_interrupt()
Definition: game.cpp:1703
void load_npcs()
Makes any nearby NPCs on the overmap active.
Definition: game.cpp:898
bool npcs_dirty
Has a NPC been spawned since last load?
Definition: game.h:1095
void cleanup_dead()
Definition: game.cpp:4377
bool is_game_over()
Definition: game.cpp:2691
void perhaps_add_random_npc()
Definition: game.cpp:11582
void mon_info_update()
Definition: game.cpp:4182
bool handle_action()
const T & obj() const
Definition: ammo_effect.cpp:26
void build_floor_caches()
Definition: map.cpp:7906
void process_falling()
Invoked drop_everything on cached dirty tiles.
Definition: map.cpp:2269
void emit_field(const tripoint &pos, const emit_id &src, float mul=1.0f)
Runs one cycle of emission src which may result in propagation of fields.
Definition: map_field.cpp:1925
const std::vector< tripoint > & get_furn_field_locations() const
Definition: map.cpp:7604
void spawn_monsters(bool ignore_sight)
Spawn monsters from submap spawn points and from the overmap.
Definition: map.cpp:7563
void vehmove()
Definition: map.cpp:410
void creature_in_field(Creature &critter)
Apply field effects to the creature when it's on a square with fields.
Definition: map_field.cpp:1560
void process_fields()
Definition: map_field.cpp:141
furn_id furn(const tripoint &p) const
Definition: map.cpp:1343
void build_map_cache(int zlev, bool skip_lightmap=false)
Definition: map.cpp:8034
void process_items()
Definition: map.cpp:4559
static void process_all()
Handles mission deadline processing.
Definition: mission.cpp:98
void set_scent(const tripoint_abs_omt &loc, int strength)
Method to set a scent trace.
void process_mongroups()
Process nearby monstergroups (dying mostly).
void move_hordes()
Let hordes move a step.
const activity_id & id() const
cata::optional< std::string > get_progress_message(const avatar &u) const
Helper that returns an activity specific progress message.
bool is_dead_state() const override
Returns true if the player should be dead.
Definition: player.cpp:819
int volume
Definition: player.h:642
int scent
Definition: player.h:651
void update_body_wetness(const w_point &weather)
Maintains body wetness and handles the rate at which the player dries.
Definition: player.cpp:1591
void process_turn() override
Resets movement points and applies other non-idempotent changes.
Definition: player.cpp:278
void set(const tripoint &p, int value, const scenttype_id &type=scenttype_id())
Get the scent value at the given position.
Definition: scent_map.cpp:102
void update(const tripoint &center, map &m)
Definition: scent_map.cpp:151
static constexpr time_duration from_minutes(const T m)
Definition: calendar.h:212
void process()
Process all queued events, potentially altering the game state and modifying the event queue.
static const activity_id ACT_AUTODRIVE("ACT_AUTODRIVE")
static const efftype_id effect_sleep("sleep")
@ QUIT_WATCH
Definition: game.h:73
static constexpr int MAX_VIEW_DISTANCE
void handle_weather_effects(const weather_type_id &w)
Definition: weather.cpp:522
bool once_every(const time_duration &event_frequency)
Predicate to handle rate-limiting.
Definition: calendar.cpp:490
explosion_queue & get_explosion_queue()
Definition: explosion.cpp:1159
void do_vehicle_engine_sfx()
Definition: sounds.cpp:1614
void do_hearing_loss(int turns=-1)
Definition: sounds.cpp:1609
void do_danger_music()
Definition: sounds.cpp:1613
void do_vehicle_exterior_engine_sfx()
Definition: sounds.cpp:1615
void do_fatigue()
Definition: sounds.cpp:1634
void remove_hearing_loss()
Definition: sounds.cpp:1610
void process_sound_markers(player *p)
Definition: sounds.cpp:386
void process_sounds()
Definition: sounds.cpp:304
void reset_markers()
Definition: sounds.cpp:572
vehicle * veh_pointer_or_null(const optional_vpart_position &p)

References _, ACT_AUTODRIVE, Character::action_taken(), Character::activity, add_artifact_dreams(), all_npcs(), Character::apply_wetness_morale(), autopilot_vehicles(), autosave(), map::build_floor_caches(), map::build_map_cache(), calc_driving_offset(), Character::check_and_recover_morale(), Character::check_mount_is_spooked(), cleanup_at_end(), cleanup_dead(), Character::controlling_vehicle, map::creature_in_field(), sfx::do_danger_music(), sfx::do_fatigue(), sfx::do_hearing_loss(), sfx::do_vehicle_engine_sfx(), sfx::do_vehicle_exterior_engine_sfx(), driving_view_offset, effect_sleep, map::emit_field(), explosion_handler::explosion_queue::execute(), first_redraw_since_waiting_started, time_duration::from_minutes(), map::furn(), gamemode, explosion_handler::get_explosion_queue(), map::get_furn_field_locations(), get_levz(), player_activity::get_progress_message(), Character::get_type_of_scent(), get_weather, Character::global_omt_location(), grid_tracker_ptr, handle_action(), vehicle::handle_potential_theft(), handle_weather_effects(), Character::has_active_bionic(), Character::has_destination(), Character::has_distant_destination(), Creature::has_effect(), Character::has_trait(), player_activity::id(), Character::in_vehicle, invalidate_main_ui_adaptor(), player::is_dead_state(), Character::is_deaf(), is_game_over(), Character::is_mounted(), Creature::is_underwater(), load_npcs(), m, MAX_VIEW_DISTANCE, mon_info_update(), monmove(), overmapbuffer::move_hordes(), Creature::moves, moves_since_last_save, new_game, npcs_dirty, int_id< T >::obj(), calendar::once_every(), overmap_buffer, overmap_npc_move(), perhaps_add_random_npc(), Character::pos(), game::debug_hour_timer::print_time(), timed_event_manager::process(), process_activity(), mission::process_all(), map::process_falling(), map::process_fields(), map::process_items(), overmapbuffer::process_mongroups(), sounds::process_sound_markers(), sounds::process_sounds(), player::process_turn(), process_voluntary_act_interrupt(), queue_screenshot, QUIT_WATCH, ui_manager::redraw(), refresh_display(), sfx::remove_hearing_loss(), reset_light_level(), sounds::reset_markers(), rl_dist(), scent, player::scent, scent_map::set(), overmapbuffer::set_scent(), map::spawn_monsters(), take_screenshot(), timed_events, calendar::turn, u, scent_map::update(), Character::update_body(), player::update_body_wetness(), Character::update_bodytemp(), Character::update_morale(), update_stair_monsters(), uquit, map::veh_at(), veh_pointer_or_null(), map::vehmove(), player::volume, wait_popup, point::x, and point::y.

◆ draw()

void game::draw ( )

Definition at line 3463 of file game.cpp.

3464{
3465 if( test_mode ) {
3466 return;
3467 }
3468
3469 //temporary fix for updating visibility for minimap
3470 ter_view_p.z = ( u.pos() + u.view_offset ).z;
3473
3474 werase( w_terrain );
3475 draw_ter();
3476 for( auto it = draw_callbacks.begin(); it != draw_callbacks.end(); ) {
3477 shared_ptr_fast<draw_callback_t> cb = it->lock();
3478 if( cb ) {
3479 ( *cb )();
3480 ++it;
3481 } else {
3482 it = draw_callbacks.erase( it );
3483 }
3484 }
3486
3487 draw_panels( true );
3488}
bool test_mode
Set to true when running in test mode (e.g.
tripoint ter_view_p
Definition: game.h:1034
void draw_panels(bool force_draw=false)
Definition: game.cpp:3490
void draw_ter(bool draw_sounds=true)
Definition: game.cpp:3604
void update_visibility_cache(int zlev)
Definition: map.cpp:5574
int z
Definition: point.h:152

References map::build_map_cache(), draw_callbacks, draw_panels(), draw_ter(), m, Character::pos(), ter_view_p, test_mode, u, map::update_visibility_cache(), player::view_offset, w_terrain, catacurses::werase(), catacurses::wnoutrefresh(), and tripoint::z.

◆ draw_below_override()

void game::draw_below_override ( const tripoint p,
bool  draw 
)

Definition at line 955 of file animation.cpp.

956{
957}

◆ draw_bullet()

void game::draw_bullet ( const tripoint t,
int  i,
const std::vector< tripoint > &  trajectory,
char  bullet 
)

Definition at line 510 of file animation.cpp.

512{
513 draw_bullet_curses( m, t, bullet, &trajectory[i] );
514}
void draw_bullet_curses(map &m, const tripoint &t, const char bullet, const tripoint *const p)
Definition: animation.cpp:451
std::vector< tripoint > trajectory
Definition: ranged.h:32

References anonymous_namespace{animation.cpp}::draw_bullet_curses(), and m.

◆ draw_critter()

void game::draw_critter ( const Creature critter,
const tripoint center 
)

Definition at line 3586 of file game.cpp.

3587{
3588 draw_critter_internal( w_terrain, critter, center, false, m, u );
3589}
static void draw_critter_internal(const catacurses::window &w, const Creature &critter, const tripoint &center, bool inverted, const map &m, const avatar &u)
Definition: game.cpp:3553

References center, draw_critter_internal(), m, u, and w_terrain.

Referenced by draw_ter().

◆ draw_critter_highlighted()

void game::draw_critter_highlighted ( const Creature critter,
const tripoint center 
)

Definition at line 3591 of file game.cpp.

3592{
3593 draw_critter_internal( w_terrain, critter, center, true, m, u );
3594}

References center, draw_critter_internal(), m, u, and w_terrain.

◆ draw_cursor()

void game::draw_cursor ( const tripoint p)

Definition at line 716 of file animation.cpp.

717{
718 const tripoint rp = relative_view_pos( *this, p );
719 mvwputch_inv( w_terrain, rp.xy(), c_light_green, 'X' );
720}
#define c_light_green
Definition: color.h:28
tripoint relative_view_pos(const game &g, const tripoint &p) noexcept
Definition: animation.cpp:119
void mvwputch_inv(const catacurses::window &w, const point &p, nc_color FG, int ch)
Definition: output.cpp:491

References c_light_green, mvwputch_inv(), anonymous_namespace{animation.cpp}::relative_view_pos(), w_terrain, and tripoint::xy().

Referenced by draw_look_around_cursor().

◆ draw_field_override()

void game::draw_field_override ( const tripoint p,
const field_type_id id 
)

Definition at line 911 of file animation.cpp.

912{
913}

◆ draw_furniture_override()

void game::draw_furniture_override ( const tripoint p,
const furn_id id 
)

Definition at line 872 of file animation.cpp.

873{
874}

◆ draw_graffiti_override()

void game::draw_graffiti_override ( const tripoint p,
bool  has 
)

Definition at line 885 of file animation.cpp.

886{
887}

◆ draw_highlight()

void game::draw_highlight ( const tripoint p)

Definition at line 729 of file animation.cpp.

730{
731 // Do nothing
732}

◆ draw_hit_mon()

void game::draw_hit_mon ( const tripoint p,
const monster m,
bool  dead = false 
)

Definition at line 573 of file animation.cpp.

574{
575 draw_hit_mon_curses( p, m, u, dead );
576}
void draw_hit_mon_curses(const tripoint &center, const monster &m, const player &u, const bool dead)
Definition: animation.cpp:544

References dead, anonymous_namespace{animation.cpp}::draw_hit_mon_curses(), m, and u.

◆ draw_hit_player()

void game::draw_hit_player ( const Character p,
int  dam 
)

Definition at line 618 of file animation.cpp.

619{
620 draw_hit_player_curses( *this, p, dam );
621}
void draw_hit_player_curses(const game &g, const Character &p, const int dam)
Definition: animation.cpp:581

References anonymous_namespace{animation.cpp}::draw_hit_player_curses().

◆ draw_item_override()

void game::draw_item_override ( const tripoint p,
const itype_id id,
const mtype_id mid,
bool  hilite 
)

Definition at line 925 of file animation.cpp.

927{
928}

◆ draw_line() [1/2]

void game::draw_line ( const tripoint p,
const std::vector< tripoint > &  points 
)

Definition at line 702 of file animation.cpp.

703{
704 draw_line_curses( *this, points );
705}
void draw_line_curses(game &g, const std::vector< tripoint > &points)
Definition: animation.cpp:682

References anonymous_namespace{animation.cpp}::draw_line_curses().

◆ draw_line() [2/2]

void game::draw_line ( const tripoint p,
const tripoint center_point,
const std::vector< tripoint > &  points,
bool  noreveal = false 
)

Definition at line 669 of file animation.cpp.

671{
672 if( !u.sees( p ) ) {
673 return;
674 }
675
676 draw_line_curses( *this, center, points, noreveal );
677}

References center, anonymous_namespace{animation.cpp}::draw_line_curses(), Character::sees(), and u.

Referenced by draw_ter().

◆ draw_look_around_cursor()

void game::draw_look_around_cursor ( const tripoint lp,
const visibility_variables cache 
)

Definition at line 5965 of file game.cpp.

5966{
5967 if( !liveview.is_enabled() ) {
5968#if defined( TILES )
5969 if( is_draw_tiles_mode() ) {
5970 draw_cursor( lp );
5971 return;
5972 }
5973#endif
5974 const tripoint view_center = u.pos() + u.view_offset;
5975 visibility_type visibility = VIS_HIDDEN;
5976 const bool inbounds = m.inbounds( lp );
5977 if( inbounds ) {
5978 visibility = m.get_visibility( m.apparent_light_at( lp, cache ), cache );
5979 }
5980 if( visibility == VIS_CLEAR ) {
5981 const Creature *const creature = critter_at( lp, true );
5982 if( creature != nullptr && u.sees( *creature ) ) {
5983 creature->draw( w_terrain, view_center, true );
5984 } else {
5985 m.drawsq( w_terrain, lp, drawsq_params().highlight( true ).center( view_center ) );
5986 }
5987 } else {
5988 std::string visibility_indicator;
5989 nc_color visibility_indicator_color = c_white;
5990 switch( visibility ) {
5991 case VIS_CLEAR:
5992 // Already handled by the outer if statement
5993 break;
5994 case VIS_BOOMER:
5995 case VIS_BOOMER_DARK:
5996 visibility_indicator = '#';
5997 visibility_indicator_color = c_pink;
5998 break;
5999 case VIS_DARK:
6000 visibility_indicator = '#';
6001 visibility_indicator_color = c_dark_gray;
6002 break;
6003 case VIS_LIT:
6004 visibility_indicator = '#';
6005 visibility_indicator_color = c_light_gray;
6006 break;
6007 case VIS_HIDDEN:
6008 visibility_indicator = 'x';
6009 visibility_indicator_color = c_white;
6010 break;
6011 }
6012
6013 const tripoint screen_pos = point( POSX, POSY ) + lp - view_center;
6014 mvwputch( w_terrain, screen_pos.xy(), visibility_indicator_color, visibility_indicator );
6015 }
6016 }
6017}
void draw_cursor(const tripoint &p)
Definition: animation.cpp:716
T * critter_at(const tripoint &p, bool allow_hallucination=false)
Returns the Creature at the given location.
Definition: game.cpp:4848
bool is_enabled()
Definition: live_view.cpp:75
virtual bool inbounds(const tripoint &p) const
Definition: map.cpp:7614
visibility_type get_visibility(lit_level ll, const visibility_variables &cache) const
Definition: map.cpp:5620
lit_level apparent_light_at(const tripoint &p, const visibility_variables &cache) const
Determine the visible light level for a tile, based on light_at for the tile, vision distance,...
Definition: lightmap.cpp:698
void drawsq(const catacurses::window &w, const tripoint &p, const drawsq_params &params) const
Draw the map tile at the given coordinate.
Definition: map.cpp:5798
#define c_dark_gray
Definition: color.h:20
#define c_pink
Definition: color.h:31
visibility_type
Definition: enums.h:57
@ VIS_CLEAR
Definition: enums.h:59
@ VIS_BOOMER
Definition: enums.h:61
@ VIS_DARK
Definition: enums.h:62
@ VIS_BOOMER_DARK
Definition: enums.h:63
@ VIS_HIDDEN
Definition: enums.h:58
@ VIS_LIT
Definition: enums.h:60
bool is_draw_tiles_mode()
Check whether we're in tile drawing mode.
Definition: output.cpp:2029
Draw parameters used by map::drawsq() and similar methods.
Definition: map.h:176

References map::apparent_light_at(), c_dark_gray, c_light_gray, c_pink, c_white, center, creature, critter_at(), draw_cursor(), map::drawsq(), map::get_visibility(), map::inbounds(), is_draw_tiles_mode(), live_view::is_enabled(), liveview, m, mvwputch(), Character::pos(), POSX, POSY, Character::sees(), u, player::view_offset, VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, VIS_LIT, w_terrain, and tripoint::xy().

Referenced by look_around().

◆ draw_minimap()

void game::draw_minimap ( )
private

Definition at line 3664 of file game.cpp.

3665{
3666
3667 // Draw the box
3668 werase( w_minimap );
3670
3671 const tripoint_abs_omt curs = u.global_omt_location();
3672 const point_abs_omt curs2( curs.xy() );
3674 bool drew_mission = targ == overmap::invalid_tripoint;
3675
3676 for( int i = -2; i <= 2; i++ ) {
3677 for( int j = -2; j <= 2; j++ ) {
3678 const point_abs_omt om( curs2 + point( i, j ) );
3679 nc_color ter_color;
3680 tripoint_abs_omt omp( om, get_levz() );
3681 std::string ter_sym;
3682 const bool seen = overmap_buffer.seen( omp );
3683 const bool vehicle_here = overmap_buffer.has_vehicle( omp );
3684 if( overmap_buffer.has_note( omp ) ) {
3685
3686 const std::string &note_text = overmap_buffer.note( omp );
3687
3688 ter_color = c_yellow;
3689 ter_sym = "N";
3690
3691 int symbolIndex = note_text.find( ':' );
3692 int colorIndex = note_text.find( ';' );
3693
3694 bool symbolFirst = symbolIndex < colorIndex;
3695
3696 if( colorIndex > -1 && symbolIndex > -1 ) {
3697 if( symbolFirst ) {
3698 if( colorIndex > 4 ) {
3699 colorIndex = -1;
3700 }
3701 if( symbolIndex > 1 ) {
3702 symbolIndex = -1;
3703 colorIndex = -1;
3704 }
3705 } else {
3706 if( symbolIndex > 4 ) {
3707 symbolIndex = -1;
3708 }
3709 if( colorIndex > 2 ) {
3710 colorIndex = -1;
3711 }
3712 }
3713 } else if( colorIndex > 2 ) {
3714 colorIndex = -1;
3715 } else if( symbolIndex > 1 ) {
3716 symbolIndex = -1;
3717 }
3718
3719 if( symbolIndex > -1 ) {
3720 int symbolStart = 0;
3721 if( colorIndex > -1 && !symbolFirst ) {
3722 symbolStart = colorIndex + 1;
3723 }
3724 ter_sym = note_text.substr( symbolStart, symbolIndex - symbolStart ).c_str()[0];
3725 }
3726
3727 if( colorIndex > -1 ) {
3728
3729 int colorStart = 0;
3730
3731 if( symbolIndex > -1 && symbolFirst ) {
3732 colorStart = symbolIndex + 1;
3733 }
3734
3735 std::string sym = note_text.substr( colorStart, colorIndex - colorStart );
3736
3737 if( sym.length() == 2 ) {
3738 if( sym == "br" ) {
3739 ter_color = c_brown;
3740 } else if( sym == "lg" ) {
3741 ter_color = c_light_gray;
3742 } else if( sym == "dg" ) {
3743 ter_color = c_dark_gray;
3744 }
3745 } else {
3746 char colorID = sym.c_str()[0];
3747 if( colorID == 'r' ) {
3748 ter_color = c_light_red;
3749 } else if( colorID == 'R' ) {
3750 ter_color = c_red;
3751 } else if( colorID == 'g' ) {
3752 ter_color = c_light_green;
3753 } else if( colorID == 'G' ) {
3754 ter_color = c_green;
3755 } else if( colorID == 'b' ) {
3756 ter_color = c_light_blue;
3757 } else if( colorID == 'B' ) {
3758 ter_color = c_blue;
3759 } else if( colorID == 'W' ) {
3760 ter_color = c_white;
3761 } else if( colorID == 'C' ) {
3762 ter_color = c_cyan;
3763 } else if( colorID == 'c' ) {
3764 ter_color = c_light_cyan;
3765 } else if( colorID == 'P' ) {
3766 ter_color = c_pink;
3767 } else if( colorID == 'm' ) {
3768 ter_color = c_magenta;
3769 }
3770 }
3771 }
3772 } else if( !seen ) {
3773 ter_sym = " ";
3774 ter_color = c_black;
3775 } else if( vehicle_here ) {
3776 ter_color = c_cyan;
3777 ter_sym = "c";
3778 } else {
3779 const oter_id &cur_ter = overmap_buffer.ter( omp );
3780 ter_sym = cur_ter->get_symbol();
3781 if( overmap_buffer.is_explored( omp ) ) {
3782 ter_color = c_dark_gray;
3783 } else {
3784 ter_color = cur_ter->get_color();
3785 }
3786 }
3787 if( !drew_mission && targ.xy() == omp.xy() ) {
3788 // If there is a mission target, and it's not on the same
3789 // overmap terrain as the player character, mark it.
3790 // TODO: Inform player if the mission is above or below
3791 drew_mission = true;
3792 if( i != 0 || j != 0 ) {
3793 ter_color = red_background( ter_color );
3794 }
3795 }
3796 if( i == 0 && j == 0 ) {
3797 mvwputch_hi( w_minimap, point( 3, 3 ), ter_color, ter_sym );
3798 } else {
3799 mvwputch( w_minimap, point( 3 + i, 3 + j ), ter_color, ter_sym );
3800 }
3801 }
3802 }
3803
3804 // Print arrow to mission if we have one!
3805 if( !drew_mission ) {
3806 double slope = curs2.x() != targ.x() ?
3807 static_cast<double>( targ.y() - curs2.y() ) / ( targ.x() - curs2.x() ) : 4;
3808
3809 if( curs2.x() == targ.x() || std::fabs( slope ) > 3.5 ) { // Vertical slope
3810 if( targ.y() > curs2.y() ) {
3811 mvwputch( w_minimap, point( 3, 6 ), c_red, "*" );
3812 } else {
3813 mvwputch( w_minimap, point( 3, 0 ), c_red, "*" );
3814 }
3815 } else {
3816 int arrowx = -1;
3817 int arrowy = -1;
3818 if( std::fabs( slope ) >= 1. ) { // y diff is bigger!
3819 arrowy = targ.y() > curs2.y() ? 6 : 0;
3820 arrowx =
3821 static_cast<int>( 3 + 3 * ( targ.y() > curs2.y() ? slope : ( 0 - slope ) ) );
3822 if( arrowx < 0 ) {
3823 arrowx = 0;
3824 }
3825 if( arrowx > 6 ) {
3826 arrowx = 6;
3827 }
3828 } else {
3829 arrowx = targ.x() > curs2.x() ? 6 : 0;
3830 arrowy = static_cast<int>( 3 + 3 * ( targ.x() > curs2.x() ? slope : -slope ) );
3831 if( arrowy < 0 ) {
3832 arrowy = 0;
3833 }
3834 if( arrowy > 6 ) {
3835 arrowy = 6;
3836 }
3837 }
3838 char glyph = '*';
3839 if( targ.z() > u.posz() ) {
3840 glyph = '^';
3841 } else if( targ.z() < u.posz() ) {
3842 glyph = 'v';
3843 }
3844
3845 mvwputch( w_minimap, point( arrowx, arrowy ), c_red, glyph );
3846 }
3847 }
3848
3849 const int sight_points = g->u.overmap_sight_range( g->light_level( g->u.posz() ) );
3850 for( int i = -3; i <= 3; i++ ) {
3851 for( int j = -3; j <= 3; j++ ) {
3852 if( i > -3 && i < 3 && j > -3 && j < 3 ) {
3853 continue; // only do hordes on the border, skip inner map
3854 }
3855 const tripoint_abs_omt omp( curs2 + point( i, j ), get_levz() );
3857 if( overmap_buffer.seen( omp )
3858 && g->u.overmap_los( omp, sight_points ) ) {
3859 mvwputch( w_minimap, point( i + 3, j + 3 ), c_green,
3860 overmap_buffer.get_horde_size( omp ) > HORDE_VISIBILITY_SIZE * 2 ? 'Z' : 'z' );
3861 }
3862 }
3863 }
3864 }
3865
3867}
tripoint_abs_omt get_active_mission_target() const
Returns the target of the active mission or overmap::invalid_tripoint if there is no active mission.
Definition: avatar.cpp:198
constexpr auto & x()
Definition: coordinates.h:118
constexpr auto & z()
Definition: coordinates.h:133
constexpr auto & y()
Definition: coordinates.h:124
constexpr auto xy() const
Definition: coordinates.h:130
static constexpr tripoint_abs_omt invalid_tripoint
Dummy value, used to indicate that a point returned by a function is invalid.
Definition: overmap.h:260
bool seen(const tripoint_abs_omt &p)
const std::string & note(const tripoint_abs_omt &p)
int get_horde_size(const tripoint_abs_omt &p)
bool is_explored(const tripoint_abs_omt &p)
const oter_id & ter(const tripoint_abs_omt &p)
Returns the overmap terrain at the given OMT coordinates.
bool has_note(const tripoint_abs_omt &p)
Uses global overmap terrain coordinates.
bool has_vehicle(const tripoint_abs_omt &p)
nc_color red_background(const nc_color &c)
Definition: color.cpp:515
#define c_blue
Definition: color.h:23
#define c_black
Definition: color.h:17
#define c_light_blue
Definition: color.h:29
#define c_yellow
Definition: color.h:32
#define c_light_cyan
Definition: color.h:30
#define c_cyan
Definition: color.h:24
#define c_light_red
Definition: color.h:27
static constexpr int HORDE_VISIBILITY_SIZE
constexpr scale om
Definition: coordinates.h:34
void mvwputch_hi(const catacurses::window &w, const point &p, nc_color FG, int ch)
Definition: output.cpp:508
std::string get_symbol(const bool from_land_use_code=false) const
Definition: omdata.h:209
nc_color get_color(const bool from_land_use_code=false) const
Definition: omdata.h:217

References c_black, c_blue, c_brown, c_cyan, c_dark_gray, c_green, c_light_blue, c_light_cyan, c_light_gray, c_light_green, c_light_red, c_magenta, c_pink, c_red, c_white, c_yellow, draw_border(), units::fabs(), g, avatar::get_active_mission_target(), oter_t::get_color(), overmapbuffer::get_horde_size(), get_levz(), oter_t::get_symbol(), Character::global_omt_location(), overmapbuffer::has_note(), overmapbuffer::has_vehicle(), HORDE_VISIBILITY_SIZE, overmap::invalid_tripoint, overmapbuffer::is_explored(), mvwputch(), mvwputch_hi(), overmapbuffer::note(), coords::om, overmap_buffer, Character::posz(), red_background(), overmapbuffer::seen(), overmapbuffer::ter(), u, w_minimap, catacurses::werase(), catacurses::wnoutrefresh(), coords::coord_point< Point, Origin, Scale >::x(), coords::coord_point< Point, Origin, Scale >::xy(), coords::coord_point< Point, Origin, Scale >::y(), and coords::coord_point< Point, Origin, Scale >::z().

◆ draw_monster_override()

void game::draw_monster_override ( const tripoint p,
const mtype_id id,
int  count,
bool  more,
Creature::Attitude  att 
)

Definition at line 969 of file animation.cpp.

971{
972}

◆ draw_panels()

void game::draw_panels ( bool  force_draw = false)

Definition at line 3490 of file game.cpp.

3491{
3492 static int previous_turn = -1;
3493 const int current_turn = to_turns<int>( calendar::turn - calendar::turn_zero );
3494 const bool draw_this_turn = current_turn > previous_turn || force_draw;
3495 auto &mgr = panel_manager::get_manager();
3496 int y = 0;
3497 const bool sidebar_right = get_option<std::string>( "SIDEBAR_POSITION" ) == "right";
3498 int spacer = get_option<bool>( "SIDEBAR_SPACERS" ) ? 1 : 0;
3499 int log_height = 0;
3500 for( const window_panel &panel : mgr.get_current_layout() ) {
3501 if( panel.get_height() != -2 && panel.toggle && panel.render() ) {
3502 log_height += panel.get_height() + spacer;
3503 }
3504 }
3505 log_height = std::max( TERMY - log_height, 3 );
3506 for( const window_panel &panel : mgr.get_current_layout() ) {
3507 if( panel.render() ) {
3508 // height clamped to window height.
3509 int h = std::min( panel.get_height(), TERMY - y );
3510 if( h == -2 ) {
3511 h = log_height;
3512 }
3513 h += spacer;
3514 if( panel.toggle && panel.render() && h > 0 ) {
3515 if( panel.always_draw || draw_this_turn ) {
3516 panel.draw( u, catacurses::newwin( h, panel.get_width(),
3517 point( sidebar_right ? TERMX - panel.get_width() : 0, y ) ) );
3518 }
3519 if( show_panel_adm ) {
3520 const std::string panel_name = _( panel.get_name() );
3521 const int panel_name_width = utf8_width( panel_name );
3522 auto label = catacurses::newwin( 1, panel_name_width, point( sidebar_right ?
3523 TERMX - panel.get_width() - panel_name_width - 1 : panel.get_width() + 1, y ) );
3524 werase( label );
3525 mvwprintz( label, point_zero, c_light_red, panel_name );
3527 label = catacurses::newwin( h, 1,
3528 point( sidebar_right ? TERMX - panel.get_width() - 1 : panel.get_width(), y ) );
3529 werase( label );
3530 if( h == 1 ) {
3532 } else {
3534 for( int i = 1; i < h - 1; i++ ) {
3536 }
3537 mvwputch( label, point( 0, h - 1 ), c_light_red, sidebar_right ? LINE_XXOO : LINE_XOOX );
3538 }
3540 }
3541 y += h;
3542 }
3543 }
3544 }
3545 previous_turn = current_turn;
3546}
bool show_panel_adm
Definition: game.h:1062
const time_point turn_zero
Represents time point 0.
Definition: calendar.cpp:26
#define LINE_XOXO
Definition: output.h:39
#define LINE_OXOX
Definition: output.h:40
#define LINE_OXXX
Definition: output.h:48
#define LINE_XOOX
Definition: output.h:44
#define LINE_XXOO
Definition: output.h:41
Struct used for storing labels (easier to json opposed to a std::map<point, std::string>)
Definition: vehicle.h:578

References _, c_light_red, panel_manager::get_manager(), LINE_OXOX, LINE_OXXX, LINE_XOOX, LINE_XOXO, LINE_XXOO, mvwprintz(), mvwputch(), catacurses::newwin(), point_zero, show_panel_adm, TERMX, TERMY, calendar::turn, calendar::turn_zero, u, utf8_width(), catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by draw().

◆ draw_pixel_minimap()

void game::draw_pixel_minimap ( const catacurses::window w)

Definition at line 3548 of file game.cpp.

3549{
3550 w_pixel_minimap = w;
3551}

References w_pixel_minimap.

◆ draw_radiation_override()

void game::draw_radiation_override ( const tripoint p,
int  rad 
)

Definition at line 846 of file animation.cpp.

847{
848}

◆ draw_sct()

void game::draw_sct ( )

Definition at line 797 of file animation.cpp.

798{
799 draw_sct_curses( *this );
800}
void draw_sct_curses(const game &g)
Definition: animation.cpp:764

References anonymous_namespace{animation.cpp}::draw_sct_curses().

Referenced by get_player_input().

◆ draw_ter() [1/2]

void game::draw_ter ( bool  draw_sounds = true)

Definition at line 3604 of file game.cpp.

3605{
3607 draw_sounds );
3608}
bool is_looking
Definition: game.h:250

References draw_ter(), is_looking, Character::pos(), u, and player::view_offset.

Referenced by draw(), and draw_ter().

◆ draw_ter() [2/2]

void game::draw_ter ( const tripoint center,
bool  looking = false,
bool  draw_sounds = true 
)

Definition at line 3610 of file game.cpp.

3611{
3613
3614 m.draw( w_terrain, center );
3615
3616 if( draw_sounds ) {
3618 }
3619
3620 for( Creature &critter : all_creatures() ) {
3621 draw_critter( critter, center );
3622 }
3623
3624 if( !destination_preview.empty() && u.view_offset.z == 0 ) {
3625 // Draw auto-move preview trail
3626 const tripoint &final_destination = destination_preview.back();
3627 tripoint line_center = u.pos() + u.view_offset;
3628 draw_line( final_destination, line_center, destination_preview, true );
3629 mvwputch( w_terrain, final_destination.xy() - u.view_offset.xy() + point( POSX - u.posx(),
3630 POSY - u.posy() ), c_white, 'X' );
3631 }
3632
3633 if( u.controlling_vehicle && !looking ) {
3634 draw_veh_dir_indicator( false );
3635 draw_veh_dir_indicator( true );
3636 }
3637 // Place the cursor over the player as is expected by screen readers.
3638 wmove( w_terrain, -center.xy() + g->u.pos().xy() + point( POSX, POSY ) );
3639}
int posx() const override
Definition: character.h:781
int posy() const override
Definition: character.h:784
void draw_critter(const Creature &critter, const tripoint &center)
Definition: game.cpp:3586
Creature_range all_creatures()
Returns an anonymous range that contains all creatures.
Definition: game.cpp:12514
std::vector< tripoint > destination_preview
Definition: game.h:1114
void draw_veh_dir_indicator(bool next)
Definition: game.cpp:3656
void draw_line(const tripoint &p, const tripoint &center_point, const std::vector< tripoint > &points, bool noreveal=false)
Definition: animation.cpp:669
void draw(const catacurses::window &w, const tripoint &center)
Draw a visible part of the map into w.
Definition: map.cpp:5670
static void draw_footsteps(const catacurses::window &window, const tripoint &offset)
Definition: game.cpp:3276
void wmove(const window &win, const point &p)
Definition: ncurses_def.cpp:98

References all_creatures(), c_white, center, Character::controlling_vehicle, destination_preview, map::draw(), draw_critter(), draw_footsteps(), draw_line(), draw_veh_dir_indicator(), g, m, mvwputch(), Character::pos(), Character::posx(), POSX, Character::posy(), POSY, ter_view_p, u, player::view_offset, w_terrain, catacurses::wmove(), tripoint::xy(), and tripoint::z.

◆ draw_terrain_override()

void game::draw_terrain_override ( const tripoint p,
const ter_id id 
)

Definition at line 859 of file animation.cpp.

860{
861}

◆ draw_trail_to_square()

void game::draw_trail_to_square ( const tripoint t,
bool  bDrawX 
)

Definition at line 7268 of file game.cpp.

7269{
7270 ::draw_trail( u.pos(), u.pos() + t, bDrawX );
7271}
static void draw_trail(const tripoint &start, const tripoint &end, bool bDrawX)
Definition: game.cpp:7238

References draw_trail(), Character::pos(), and u.

◆ draw_trap_override()

void game::draw_trap_override ( const tripoint p,
const trap_id id 
)

Definition at line 898 of file animation.cpp.

899{
900}

◆ draw_veh_dir_indicator()

void game::draw_veh_dir_indicator ( bool  next)

Definition at line 3656 of file game.cpp.

3657{
3658 if( const cata::optional<tripoint> indicator_offset = get_veh_dir_indicator_location( next ) ) {
3659 auto col = next ? c_white : c_dark_gray;
3660 mvwputch( w_terrain, indicator_offset->xy() - u.view_offset.xy() + point( POSX, POSY ), col, 'X' );
3661 }
3662}
cata::optional< tripoint > get_veh_dir_indicator_location(bool next) const
Returns the location where the indicator should go relative to the reality bubble,...
Definition: game.cpp:3641

References c_dark_gray, c_white, get_veh_dir_indicator_location(), mvwputch(), POSX, POSY, u, player::view_offset, w_terrain, and tripoint::xy().

Referenced by draw_ter().

◆ draw_vpart_override()

void game::draw_vpart_override ( const tripoint p,
const vpart_id id,
int  part_mod,
units::angle  veh_dir,
bool  hilite,
const point mount 
)

Definition at line 941 of file animation.cpp.

943{
944}

◆ draw_weather()

void game::draw_weather ( const weather_printable wPrint)

Definition at line 756 of file animation.cpp.

757{
759}
void draw_weather_curses(const catacurses::window &win, const weather_printable &w)
Definition: animation.cpp:737

References anonymous_namespace{animation.cpp}::draw_weather_curses(), and w_terrain.

Referenced by get_player_input().

◆ draw_zones()

void game::draw_zones ( const tripoint start,
const tripoint end,
const tripoint offset 
)

Definition at line 832 of file animation.cpp.

833{
834 draw_zones_curses( w_terrain, start, end, offset );
835}
void draw_zones_curses(const catacurses::window &w, const tripoint &start, const tripoint &end, const tripoint &offset)
Definition: animation.cpp:805

References anonymous_namespace{animation.cpp}::draw_zones_curses(), and w_terrain.

◆ drop()

void game::drop ( )
private

Definition at line 8310 of file game.cpp.

8311{
8313}
void drop(item_location loc, const tripoint &where)
Drops an item to the specified location.
Definition: character.cpp:2508
drop_locations multidrop(player &p)
Select items to drop.

References Character::drop(), game_menus::inv::multidrop(), Character::pos(), and u.

Referenced by handle_action().

◆ drop_in_direction()

void game::drop_in_direction ( )
private

Definition at line 8315 of file game.cpp.

8316{
8317 if( const cata::optional<tripoint> pnt = choose_adjacent( _( "Drop where?" ) ) ) {
8318 u.drop( game_menus::inv::multidrop( u ), *pnt );
8319 }
8320}

References _, choose_adjacent(), Character::drop(), game_menus::inv::multidrop(), and u.

Referenced by handle_action().

◆ dump_stats()

bool game::dump_stats ( const std::string &  what,
dump_mode  mode,
const std::vector< std::string > &  opts 
)

write statistics to stdout and

Returns
true if successful

Definition at line 37 of file dump.cpp.

39{
40 try {
41 loading_ui ui( false );
43 load_packs( _( "Loading content packs" ), { mod_id( "dda" ) }, ui );
45 } catch( const std::exception &err ) {
46 std::cerr << "Error loading data from json: " << err.what() << std::endl;
47 return false;
48 }
49
50 std::vector<std::string> header;
51 std::vector<std::vector<std::string>> rows;
52
53 int scol = 0; // sorting column
54
55 std::map<std::string, standard_npc> test_npcs;
56 test_npcs[ "S1" ] = standard_npc( "S1", { 0, 0, 2 }, { "gloves_survivor", "mask_lsurvivor" },
57 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
58 test_npcs[ "S2" ] = standard_npc( "S2", { 0, 0, 3 }, { "gloves_fingerless", "sunglasses" },
59 4, 8, 8, 8, 10 /* PER 10 */ );
60 test_npcs[ "S3" ] = standard_npc( "S3", { 0, 0, 4 }, { "gloves_plate", "helmet_plate" },
61 4, 10, 8, 8, 8 /* STAT 10 */ );
62 test_npcs[ "S4" ] = standard_npc( "S4", { 0, 0, 5 }, {}, 0, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
63 test_npcs[ "S5" ] = standard_npc( "S5", { 0, 0, 6 }, {}, 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
64 test_npcs[ "S6" ] = standard_npc( "S6", { 0, 0, 7 }, { "gloves_hsurvivor", "mask_hsurvivor" },
65 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
66
67 std::map<std::string, item> test_items;
68 test_items[ "G1" ] = item( "glock_19" ).ammo_set( itype_id( "9mm" ) );
69 test_items[ "G2" ] = item( "hk_mp5" ).ammo_set( itype_id( "9mm" ) );
70 test_items[ "G3" ] = item( "ar15" ).ammo_set( itype_id( "223" ) );
71 test_items[ "G4" ] = item( "remington_700" ).ammo_set( itype_id( "270" ) );
72 test_items[ "G4" ].put_in( item( "rifle_scope" ) );
73
74 if( what == "AMMO" ) {
75 header = {
76 "Name", "Ammo", "Volume", "Weight", "Stack",
77 "Range", "Dispersion", "Recoil", "Damage", "Pierce", "Damage multiplier"
78 };
79 auto dump = [&rows]( const item & obj ) {
80 std::vector<std::string> r;
81 r.push_back( obj.tname( 1, false ) );
82 r.push_back( obj.ammo_type().str() );
83 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
84 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
85 r.push_back( std::to_string( obj.type->stack_size ) );
86 r.push_back( std::to_string( obj.type->ammo->range ) );
87 r.push_back( std::to_string( obj.type->ammo->dispersion ) );
88 r.push_back( std::to_string( obj.type->ammo->recoil ) );
89 damage_instance damage = obj.type->ammo->damage;
90 r.push_back( std::to_string( damage.total_damage() ) );
91 r.push_back( std::to_string( damage.empty() ? 0 : ( *damage.begin() ).res_pen ) );
92 rows.push_back( r );
93 };
94 for( const itype *e : item_controller->all() ) {
95 if( e->ammo ) {
96 dump( item( e, calendar::turn, item::solitary_tag {} ) );
97 }
98 }
99
100 } else if( what == "ARMOR" ) {
101 header = {
102 "Name", "Encumber (fit)", "Warmth", "Weight", "Storage", "Coverage", "Bash", "Cut", "Bullet", "Acid", "Fire"
103 };
104 auto dump = [&rows]( const item & obj ) {
105 std::vector<std::string> r;
106 r.push_back( obj.tname( 1, false ) );
107 r.push_back( std::to_string( obj.get_encumber( g->u ) ) );
108 r.push_back( std::to_string( obj.get_warmth() ) );
109 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
110 r.push_back( std::to_string( obj.get_storage() / units::legacy_volume_factor ) );
111 r.push_back( std::to_string( obj.get_coverage() ) );
112 r.push_back( std::to_string( obj.bash_resist() ) );
113 r.push_back( std::to_string( obj.cut_resist() ) );
114 r.push_back( std::to_string( obj.bullet_resist() ) );
115 r.push_back( std::to_string( obj.acid_resist() ) );
116 r.push_back( std::to_string( obj.fire_resist() ) );
117 rows.push_back( r );
118 };
119
120 body_part bp = opts.empty() ? num_bp : get_body_part_token( opts.front() );
121
122 for( const itype *e : item_controller->all() ) {
123 if( e->armor ) {
124 item obj( e );
125 if( bp == num_bp || obj.covers( bp ) ) {
126 if( obj.has_flag( flag_VARSIZE ) ) {
127 obj.set_flag( "FIT" );
128 }
129 dump( obj );
130 }
131 }
132 }
133
134 } else if( what == "EDIBLE" ) {
135 header = {
136 "Name", "Volume", "Weight", "Stack", "Calories", "Quench", "Healthy"
137 };
138 for( const auto &v : vitamin::all() ) {
139 header.push_back( v.second.name() );
140 }
141 auto dump = [&rows]( const item & obj ) {
142 std::vector<std::string> r;
143 r.push_back( obj.tname( 1, false ) );
144 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
145 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
146 r.push_back( std::to_string( obj.type->stack_size ) );
147 r.push_back( std::to_string( obj.get_comestible()->default_nutrition.kcal ) );
148 r.push_back( std::to_string( obj.get_comestible()->quench ) );
149 r.push_back( std::to_string( obj.get_comestible()->healthy ) );
150 auto vits = obj.get_comestible()->default_nutrition.vitamins;
151 for( const auto &v : vitamin::all() ) {
152 r.push_back( std::to_string( vits[ v.first ] ) );
153 }
154 rows.push_back( r );
155 };
156
157 for( const itype *e : item_controller->all() ) {
159
160 if( food.is_food() && g->u.can_eat( food ).success() ) {
161 dump( food );
162 }
163 }
164
165 } else if( what == "GUN" ) {
166 header = {
167 "Name", "Ammo", "Volume", "Weight", "Capacity",
168 "Range", "Dispersion", "Effective recoil", "Damage", "Pierce",
169 "Aim time", "Effective range", "Snapshot range", "Max range"
170 };
171
172 std::set<std::string> locations;
173 for( const itype *e : item_controller->all() ) {
174 if( e->gun ) {
175 std::transform( e->gun->valid_mod_locations.begin(),
176 e->gun->valid_mod_locations.end(),
177 std::inserter( locations, locations.begin() ),
178 []( const std::pair<gunmod_location, int> &q ) {
179 return q.first.name();
180 } );
181 }
182 }
183 for( const auto &e : locations ) {
184 header.push_back( e );
185 }
186
187 auto dump = [&rows, &locations]( const standard_npc & who, const item & obj ) {
188 std::vector<std::string> r;
189 r.push_back( obj.tname( 1, false ) );
190 r.push_back( !obj.ammo_types().empty() ? enumerate_as_string( obj.ammo_types().begin(),
191 obj.ammo_types().end(), []( const ammotype & at ) {
192 return at.str();
194 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
195 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
196 r.push_back( std::to_string( obj.ammo_capacity() ) );
197 r.push_back( std::to_string( obj.gun_range() ) );
198 r.push_back( std::to_string( obj.gun_dispersion() ) );
199 r.push_back( std::to_string( obj.gun_recoil() ) );
200 damage_instance damage = obj.gun_damage();
201 r.push_back( std::to_string( damage.total_damage() ) );
202 r.push_back( std::to_string( damage.empty() ? 0 : ( *damage.begin() ).res_pen ) );
203
204 r.push_back( std::to_string( who.gun_engagement_moves( obj ) ) );
205
206 for( const auto &e : locations ) {
207 const auto &vml = obj.type->gun->valid_mod_locations;
208 const auto iter = vml.find( e );
209 r.push_back( std::to_string( iter != vml.end() ? iter->second : 0 ) );
210 }
211 rows.push_back( r );
212 };
213 for( const itype *e : item_controller->all() ) {
214 if( e->gun ) {
215 item gun( e );
216 if( !gun.magazine_integral() ) {
217 gun.put_in( item( gun.magazine_default() ) );
218 }
219 gun.ammo_set( gun.ammo_default( false ), gun.ammo_capacity() );
220
221 dump( test_npcs[ "S1" ], gun );
222
223 if( gun.type->gun->barrel_length > 0_ml ) {
224 gun.put_in( item( "barrel_small" ) );
225 dump( test_npcs[ "S1" ], gun );
226 }
227 }
228 }
229
230 } else if( what == "RECIPE" ) {
231
232 // optionally filter recipes to include only those using specified skills
233 recipe_subset dict;
234 for( const auto &r : recipe_dict ) {
235 if( opts.empty() || std::any_of( opts.begin(), opts.end(), [&r]( const std::string & s ) {
236 if( r.second.skill_used == skill_id( s ) && r.second.difficulty > 0 ) {
237 return true;
238 }
239 const auto iter = r.second.required_skills.find( skill_id( s ) );
240 return iter != r.second.required_skills.end() && iter->second > 0;
241 } ) ) {
242 dict.include( &r.second );
243 }
244 }
245
246 // only consider skills that are required by at least one recipe
247 std::vector<Skill> sk;
248 std::copy_if( Skill::skills.begin(), Skill::skills.end(),
249 std::back_inserter( sk ), [&dict]( const Skill & s ) {
250 return std::any_of( dict.begin(), dict.end(), [&s]( const recipe * r ) {
251 return r->skill_used == s.ident() ||
252 r->required_skills.find( s.ident() ) != r->required_skills.end();
253 } );
254 } );
255
256 header = { "Result" };
257
258 for( const auto &e : sk ) {
259 header.push_back( e.ident().str() );
260 }
261
262 for( const recipe *e : dict ) {
263 std::vector<std::string> r;
264 r.push_back( e->result_name() );
265 for( const auto &s : sk ) {
266 if( e->skill_used == s.ident() ) {
267 r.push_back( std::to_string( e->difficulty ) );
268 } else {
269 auto iter = e->required_skills.find( s.ident() );
270 r.push_back( std::to_string( iter != e->required_skills.end() ? iter->second : 0 ) );
271 }
272 }
273 rows.push_back( r );
274 }
275
276 } else if( what == "VEHICLE" ) {
277 header = {
278 "Name", "Weight (empty)", "Weight (fueled)",
279 "Max velocity (mph)", "Safe velocity (mph)", "Acceleration (mph/turn)",
280 "Aerodynamics coeff", "Rolling coeff", "Static Drag", "Offroad %"
281 };
282 auto dump = [&rows]( const vproto_id & obj ) {
283 vehicle veh_empty( obj, 0, 0 );
284 vehicle veh_fueled( obj, 100, 0 );
285
286 std::vector<std::string> r;
287 r.push_back( veh_empty.name );
288 r.push_back( std::to_string( to_kilogram( veh_empty.total_mass() ) ) );
289 r.push_back( std::to_string( to_kilogram( veh_fueled.total_mass() ) ) );
290 r.push_back( std::to_string( veh_fueled.max_velocity() / 100 ) );
291 r.push_back( std::to_string( veh_fueled.safe_velocity() / 100 ) );
292 r.push_back( std::to_string( veh_fueled.acceleration() / 100 ) );
293 r.push_back( std::to_string( veh_fueled.coeff_air_drag() ) );
294 r.push_back( std::to_string( veh_fueled.coeff_rolling_drag() ) );
295 r.push_back( std::to_string( veh_fueled.static_drag( false ) ) );
296 r.push_back( std::to_string( static_cast<int>( 50 *
297 veh_fueled.k_traction( veh_fueled.wheel_area() ) ) ) );
298 rows.push_back( r );
299 };
300 for( auto &e : vehicle_prototype::get_all() ) {
301 dump( e );
302 }
303
304 } else if( what == "VPART" ) {
305 header = {
306 "Name", "Location", "Weight", "Size"
307 };
308 auto dump = [&rows]( const vpart_info & obj ) {
309 std::vector<std::string> r;
310 r.push_back( obj.name() );
311 r.push_back( obj.location );
312 int w = std::ceil( to_gram( item( obj.item ).weight() ) / 1000.0 );
313 r.push_back( std::to_string( w ) );
314 r.push_back( std::to_string( obj.size / units::legacy_volume_factor ) );
315 rows.push_back( r );
316 };
317 for( const auto &e : vpart_info::all() ) {
318 dump( e.second );
319 }
320
321 } else {
322 std::cerr << "unknown argument: " << what << std::endl;
323 return false;
324 }
325
326 rows.erase( std::remove_if( rows.begin(), rows.end(), []( const std::vector<std::string> &e ) {
327 return e.empty();
328 } ), rows.end() );
329
330 if( scol >= 0 ) {
331 std::sort( rows.begin(), rows.end(), [&scol]( const std::vector<std::string> &lhs,
332 const std::vector<std::string> &rhs ) {
333 return localized_compare( lhs[ scol ], rhs[ scol ] );
334 } );
335 }
336
337 rows.erase( std::unique( rows.begin(), rows.end() ), rows.end() );
338
339 switch( mode ) {
340 case dump_mode::TSV:
341 rows.insert( rows.begin(), header );
342 for( const auto &r : rows ) {
343 // NOLINTNEXTLINE(cata-text-style): using tab to align the output
344 std::copy( r.begin(), r.end() - 1, std::ostream_iterator<std::string>( std::cout, "\t" ) );
345 std::cout << r.back() << "\n";
346 }
347 break;
348
349 case dump_mode::HTML:
350 std::cout << "<table>";
351
352 std::cout << "<thead>";
353 std::cout << "<tr>";
354 for( const auto &col : header ) {
355 std::cout << "<th>" << col << "</th>";
356 }
357 std::cout << "</tr>";
358 std::cout << "</thead>";
359
360 std::cout << "<tdata>";
361 for( const auto &r : rows ) {
362 std::cout << "<tr>";
363 for( const auto &col : r ) {
364 std::cout << "<td>" << col << "</td>";
365 }
366 std::cout << "</tr>";
367 }
368 std::cout << "</tdata>";
369
370 std::cout << "</table>";
371 break;
372 }
373
374 return true;
375}
body_part get_body_part_token(const std::string &id)
Returns the matching body_part token from the corresponding body_part string.
Definition: bodypart.cpp:180
body_part
Definition: bodypart.h:39
std::string to_string(const time_duration &d)
Returns a string showing a duration.
Definition: calendar.cpp:327
Definition: skill.h:33
static std::vector< Skill > skills
Definition: skill.h:49
const skill_id & ident() const
Definition: skill.h:65
bool load_packs(const std::string &msg, const std::vector< mod_id > &packs, loading_ui &ui)
Load content packs.
Definition: game.cpp:2981
units::mass weight(bool include_contents=true, bool integral=false) const
Definition: item.cpp:4838
void put_in(const item &payload)
Puts the given item into this one, no checks are performed.
Definition: item.cpp:989
item & ammo_set(const itype_id &ammo, int qty=-1)
Filter setting the ammo for this instance Any existing ammo is removed.
Definition: item.cpp:589
std::set< constrecipe * >::const_iterator begin() const
std::set< constrecipe * >::const_iterator end() const
void include(const recipe *r, int custom_difficulty=-1)
Include a recipe to the subset.
Definition: recipe.h:35
An NPC with standard stats.
Definition: npc.h:1394
static const std::map< vitamin_id, vitamin > & all()
Get all currently loaded vitamins.
Definition: vitamin.cpp:98
static const std::map< vpart_id, vpart_info > & all()
Definition: veh_type.cpp:694
static const std::string flag_VARSIZE("VARSIZE")
std::unique_ptr< Item_factory > item_controller
void transform(player &p, const tripoint &pos)
Transform the examined object into the object specified by its transforms_into property.
Definition: iexamine.cpp:1589
static constexpr volume legacy_volume_factor
Definition: units_volume.h:50
constexpr value_type to_gram(const quantity< value_type, mass_in_milligram_tag > &v)
Definition: units_mass.h:67
constexpr value_type to_kilogram(const quantity< value_type, mass_in_milligram_tag > &v)
Definition: units_mass.h:73
std::string enumerate_as_string(const _Container &values, enumeration_conjunction conj=enumeration_conjunction::and_)
Definition: output.h:679
recipe_dictionary recipe_dict
float total_damage() const
Definition: damage.cpp:75
std::vector< damage_unit >::iterator begin()
Definition: damage.cpp:120
bool empty() const
Definition: damage.cpp:88
Default (or randomized) charges except if counted by charges then only one charge.
Definition: item.h:196
Definition: itype.h:836
static std::vector< vproto_id > get_all()
Definition: veh_type.cpp:1157
string_id< MOD_INFORMATION > mod_id
Definition: type_id.h:91

References _, vitamin::all(), item::ammo_capacity(), item::ammo_default(), item::ammo_set(), damage_instance::begin(), item::covers(), damage_instance::empty(), enumerate_as_string(), DynamicDataLoader::finalize_loaded_data(), flag_VARSIZE(), g, get_body_part_token(), DynamicDataLoader::get_instance(), itype::gun, item::has_flag(), Skill::ident(), recipe_subset::include(), item_controller, itype_id, units::legacy_volume_factor, load_core_data(), load_packs(), anonymous_namespace{overmap_location.cpp}::locations, item::magazine_default(), item::magazine_integral(), none, num_bp, item::put_in(), recipe_dict, item::set_flag(), Skill::skills, units::to_gram(), to_string(), damage_instance::total_damage(), iexamine::transform(), calendar::turn, and item::type.

◆ events()

event_bus & game::events ( )

Definition at line 3091 of file game.cpp.

3092{
3093 return *event_bus_ptr;
3094}
pimpl< event_bus > event_bus_ptr
Definition: game.h:1001

References event_bus_ptr.

Referenced by cleanup_at_end(), and game().

◆ exam_vehicle()

void game::exam_vehicle ( vehicle veh,
const point cp = point_zero 
)

open vehicle interaction screen

Definition at line 5286 of file game.cpp.

5287{
5288 if( veh.magic ) {
5289 add_msg( m_info, _( "This is your %s" ), veh.name );
5290 return;
5291 }
5292 auto act = veh_interact::run( veh, c );
5293 if( act ) {
5294 u.moves = 0;
5296 }
5297}
static player_activity run(vehicle &veh, const point &p)
bool magic
Definition: vehicle.h:1846
constexpr double c
Definition: magic.cpp:1032
activity_id act
Definition: sounds.cpp:75

References _, act, add_msg(), Character::assign_activity(), c, m_info, vehicle::magic, Creature::moves, vehicle::name, veh_interact::run(), and u.

◆ examine() [1/2]

void game::examine ( )
private

Definition at line 5666 of file game.cpp.

5667{
5668 // if we are driving a vehicle, examine the
5669 // current tile without asking.
5670 const optional_vpart_position vp = m.veh_at( u.pos() );
5671 if( vp && vp->vehicle().player_in_control( u ) ) {
5672 examine( u.pos() );
5673 return;
5674 }
5675
5676 const cata::optional<tripoint> examp_ = choose_adjacent_highlight( _( "Examine where?" ),
5677 _( "There is nothing that can be examined nearby." ),
5678 ACTION_EXAMINE, false );
5679 if( !examp_ ) {
5680 return;
5681 }
5682 u.manual_examine = true;
5683 examine( *examp_ );
5684 u.manual_examine = false;
5685}
cata::optional< tripoint > choose_adjacent_highlight(const std::string &message, const std::string &failure_message, const action_id action, bool allow_vertical)
Request player input of adjacent tile with highlighting, possibly on different z-level.
Definition: action.cpp:1019
@ ACTION_EXAMINE
Examine or pick up items from adjacent square.
Definition: action.h:105
void examine()
Definition: game.cpp:5666
bool manual_examine
Definition: player.h:655

References _, ACTION_EXAMINE, choose_adjacent_highlight(), examine(), m, player::manual_examine, Character::pos(), u, and map::veh_at().

Referenced by examine(), and handle_action().

◆ examine() [2/2]

void game::examine ( const tripoint p)
private

Definition at line 5754 of file game.cpp.

5755{
5756 if( disable_robot( examp ) ) {
5757 return;
5758 }
5759
5760 Creature *c = critter_at( examp );
5761 if( c != nullptr ) {
5762 monster *mon = dynamic_cast<monster *>( c );
5763 if( mon != nullptr ) {
5764 add_msg( _( "There is a %s." ), mon->get_name() );
5765 if( mon->has_effect( effect_pet ) && !u.is_mounted() ) {
5766 if( monexamine::pet_menu( *mon ) ) {
5767 return;
5768 }
5769 } else if( mon->has_flag( MF_RIDEABLE_MECH ) && !mon->has_effect( effect_pet ) ) {
5770 if( monexamine::mech_hack( *mon ) ) {
5771 return;
5772 }
5773 } else if( mon->has_flag( MF_PAY_BOT ) ) {
5774 if( monexamine::pay_bot( *mon ) ) {
5775 return;
5776 }
5777 } else if( mon->attitude_to( u ) == Creature::A_FRIENDLY && !u.is_mounted() ) {
5778 if( monexamine::mfriend_menu( *mon ) ) {
5779 return;
5780 }
5781 }
5782 } else if( u.is_mounted() ) {
5783 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5784 }
5785 npc *np = dynamic_cast<npc *>( c );
5786 if( np != nullptr && !u.is_mounted() ) {
5787 if( npc_menu( *np ) ) {
5788 return;
5789 }
5790 } else if( np != nullptr && u.is_mounted() ) {
5791 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5792 }
5793 }
5794
5795 const optional_vpart_position vp = m.veh_at( examp );
5796 if( vp && u.is_mounted() ) {
5797 if( !u.mounted_creature->has_flag( MF_RIDEABLE_MECH ) ) {
5798 add_msg( m_warning, _( "You cannot interact with a vehicle while mounted." ) );
5799 } else {
5800 vp->vehicle().interact_with( examp, vp->part_index() );
5801 return;
5802 }
5803 } else if( vp && !u.is_mounted() ) {
5804 vp->vehicle().interact_with( examp, vp->part_index() );
5805 return;
5806 }
5807
5808 if( m.has_flag( "CONSOLE", examp ) && !u.is_mounted() ) {
5809 use_computer( examp );
5810 return;
5811 } else if( m.has_flag( "CONSOLE", examp ) && u.is_mounted() ) {
5812 add_msg( m_warning, _( "You cannot use a console while mounted." ) );
5813 }
5814 const furn_t &xfurn_t = m.furn( examp ).obj();
5815 const ter_t &xter_t = m.ter( examp ).obj();
5816
5817 const tripoint player_pos = u.pos();
5818
5819 if( m.has_furn( examp ) && !u.is_mounted() ) {
5820 xfurn_t.examine( u, examp );
5821 } else if( m.has_furn( examp ) && u.is_mounted() ) {
5822 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5823 } else {
5824 if( !u.is_mounted() ) {
5825 xter_t.examine( u, examp );
5826 } else if( u.is_mounted() && xter_t.examine == &iexamine::none ) {
5827 xter_t.examine( u, examp );
5828 } else {
5829 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5830 }
5831 }
5832
5833 // Did the player get moved? Bail out if so; our examp probably
5834 // isn't valid anymore.
5835 if( player_pos != u.pos() ) {
5836 return;
5837 }
5838
5839 bool none = true;
5840 if( xter_t.examine != &iexamine::none || xfurn_t.examine != &iexamine::none ) {
5841 none = false;
5842 }
5843
5844 if( !m.tr_at( examp ).is_null() && !u.is_mounted() ) {
5845 iexamine::trap( u, examp );
5846 } else if( !m.tr_at( examp ).is_null() && u.is_mounted() ) {
5847 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5848 }
5849
5850 // In case of teleport trap or somesuch
5851 if( player_pos != u.pos() ) {
5852 return;
5853 }
5854
5855 // Feedback for fire lasting time, this can be judged while mounted
5856 const std::string fire_fuel = get_fire_fuel_string( examp );
5857 if( !fire_fuel.empty() ) {
5858 add_msg( fire_fuel );
5859 }
5860
5861 if( m.has_flag( "SEALED", examp ) ) {
5862 if( none ) {
5863 if( m.has_flag( "UNSTABLE", examp ) ) {
5864 add_msg( _( "The %s is too unstable to remove anything." ), m.name( examp ) );
5865 } else {
5866 add_msg( _( "The %s is firmly sealed." ), m.name( examp ) );
5867 }
5868 }
5869 } else {
5870 //examp has no traps, is a container and doesn't have a special examination function
5871 if( m.tr_at( examp ).is_null() && m.i_at( examp ).empty() &&
5872 m.has_flag( "CONTAINER", examp ) && none ) {
5873 add_msg( _( "It is empty." ) );
5874 } else if( ( m.has_flag( TFLAG_FIRE_CONTAINER, examp ) &&
5875 xfurn_t.examine == &iexamine::fireplace ) ||
5876 xfurn_t.examine == &iexamine::workbench ) {
5877 return;
5878 } else {
5880 if( !u.is_mounted() ) {
5881 pickup::pick_up( examp, 0 );
5882 }
5883 }
5884 }
5885}
shared_ptr_fast< monster > mounted_creature
Definition: character.h:1564
@ A_FRIENDLY
Definition: creature.h:171
void use_computer(const tripoint &p)
Checks to see if a player can use a computer (not illiterate, etc.) and uses if able.
Definition: game.cpp:4816
bool disable_robot(const tripoint &p)
If there is a robot (that can be disabled), query the player and try to disable it.
Definition: game.cpp:9190
bool npc_menu(npc &who)
Returns true if the menu handled stuff and player shouldn't do anything else.
Definition: game.cpp:5557
bool empty() const
Definition: item_stack.cpp:15
bool has_furn(const tripoint &p) const
Definition: map.cpp:1338
const trap & tr_at(const tripoint &p) const
Definition: map.cpp:5115
ter_id ter(const tripoint &p) const
Definition: map.cpp:1493
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
Definition: monster.cpp:1020
std::string get_name() const override
Definition: monster.cpp:487
static const efftype_id effect_pet("pet")
static std::string get_fire_fuel_string(const tripoint &examp)
Definition: game.cpp:5687
@ TFLAG_FIRE_CONTAINER
Definition: mapdata.h:293
void fireplace(player &p, const tripoint &examp)
Definition: iexamine.cpp:2841
void workbench(player &p, const tripoint &examp)
Definition: iexamine.cpp:6022
void none(player &p, const tripoint &examp)
Nothing player can interact with here.
Definition: iexamine.cpp:244
void trap(player &p, const tripoint &examp)
Definition: iexamine.cpp:3740
bool pet_menu(monster &z)
Definition: monexamine.cpp:64
bool mech_hack(monster &z)
Definition: monexamine.cpp:373
bool mfriend_menu(monster &z)
Definition: monexamine.cpp:445
bool pay_bot(monster &z)
Definition: monexamine.cpp:405
void pick_up(const tripoint &p, int min, from_where get_items_from=prompt)
Pick up items; 'g' or ',' or via examine()
Definition: pickup.cpp:571
iexamine_function examine
Definition: mapdata.h:398
Definition: mapdata.h:457
bool is_null() const
Whether this is the null-traps, aka no trap at all.
Definition: trap.cpp:245

References _, Creature::A_FRIENDLY, add_msg(), monster::attitude_to(), c, critter_at(), disable_robot(), effect_pet, item_stack::empty(), map_data_common_t::examine, iexamine::fireplace(), map::furn(), get_fire_fuel_string(), monster::get_name(), Creature::has_effect(), map::has_flag(), monster::has_flag(), map::has_furn(), map::i_at(), Character::is_mounted(), trap::is_null(), m, m_warning, monexamine::mech_hack(), MF_PAY_BOT, MF_RIDEABLE_MECH, monexamine::mfriend_menu(), Character::mounted_creature, map::name(), none, iexamine::none(), npc_menu(), int_id< T >::obj(), monexamine::pay_bot(), monexamine::pet_menu(), pickup::pick_up(), Character::pos(), sounds::process_sound_markers(), map::ter(), TFLAG_FIRE_CONTAINER, map::tr_at(), iexamine::trap(), u, use_computer(), map::veh_at(), and iexamine::workbench().

◆ extended_description()

void game::extended_description ( const tripoint p)

Long description of (visible) things at tile.

Definition at line 50 of file descriptions.cpp.

51{
53 const int top = 3;
54 int width = 0;
55 catacurses::window w_head;
56 catacurses::window w_main;
57 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
58 const int left = 0;
59 const int right = TERMX;
60 const int bottom = TERMY;
61 width = right - left;
62 const int height = bottom - top;
63 w_head = catacurses::newwin( top, TERMX, point_zero );
64 w_main = catacurses::newwin( height, width, point( left, top ) );
65 ui.position( point_zero, point( TERMX, TERMY ) );
66 } );
67 ui.mark_resize();
68
69 // Default to critter (if any), furniture (if any), then terrain.
71 if( seen_critter( *this, p ) != nullptr ) {
73 } else if( get_map().has_furn( p ) ) {
75 }
76
77 std::string action;
78 input_context ctxt( "EXTENDED_DESCRIPTION" );
79 ctxt.register_action( "CREATURE" );
80 ctxt.register_action( "FURNITURE" );
81 ctxt.register_action( "TERRAIN" );
82 ctxt.register_action( "CONFIRM" );
83 ctxt.register_action( "QUIT" );
84 ctxt.register_action( "HELP_KEYBINDINGS" );
85
86 ui.on_redraw( [&]( const ui_adaptor & ) {
87 werase( w_head );
89 _( "[%s] describe creatures, [%s] describe furniture, "
90 "[%s] describe terrain, [%s] close." ),
91 ctxt.get_desc( "CREATURE" ), ctxt.get_desc( "FURNITURE" ),
92 ctxt.get_desc( "TERRAIN" ), ctxt.get_desc( "QUIT" ) );
93
94 // Set up line drawings
95 for( int i = 0; i < TERMX; i++ ) {
96 mvwputch( w_head, point( i, top - 1 ), c_white, LINE_OXOX );
97 }
98
99 wnoutrefresh( w_head );
100
101 std::string desc;
102 // Allow looking at invisible tiles - player may want to examine hallucinations etc.
103 switch( cur_target ) {
105 const Creature *critter = seen_critter( *this, p );
106 if( critter != nullptr ) {
107 desc = critter->extended_description();
108 } else {
109 desc = _( "You do not see any creature here." );
110 }
111 }
112 break;
114 if( !u.sees( p ) || !m.has_furn( p ) ) {
115 desc = _( "You do not see any furniture here." );
116 } else {
117 const furn_id fid = m.furn( p );
118 desc = fid.obj().extended_description();
119 }
120 break;
122 if( !u.sees( p ) ) {
123 desc = _( "You can't see the terrain here." );
124 } else {
125 const ter_id tid = m.ter( p );
126 desc = tid.obj().extended_description();
127 }
128 break;
129 }
130
131 std::string signage = m.get_signage( p );
132 if( !signage.empty() ) {
133 // NOLINTNEXTLINE(cata-text-style): the question mark does not end a sentence
134 desc += u.has_trait( trait_ILLITERATE ) ? _( "\nSign: ???" ) : string_format( _( "\nSign: %s" ),
135 signage );
136 }
137
138 werase( w_main );
139 fold_and_print_from( w_main, point_zero, width, 0, c_light_gray, desc );
140 wnoutrefresh( w_main );
141 } );
142
143 do {
145 action = ctxt.handle_input();
146 if( action == "CREATURE" ) {
147 cur_target = description_target::creature;
148 } else if( action == "FURNITURE" ) {
150 } else if( action == "TERRAIN" ) {
151 cur_target = description_target::terrain;
152 }
153 } while( action != "CONFIRM" && action != "QUIT" );
154}
virtual std::string extended_description() const =0
friend map & get_map()
Definition: map.cpp:142
std::string get_signage(const tripoint &p) const
Definition: map.cpp:3979
static const trait_id trait_ILLITERATE("ILLITERATE")
static const Creature * seen_critter(const game &g, const tripoint &p)
description_target
int fold_and_print_from(const catacurses::window &w, const point &begin, int width, int begin_line, const nc_color &base_color, const std::string &text)
Like fold_and_print, but starts the output with the N-th line of the folded string.
Definition: output.cpp:311
std::string extended_description() const

References _, action, c_light_gray, c_white, creature, map_data_common_t::extended_description(), Creature::extended_description(), fold_and_print_from(), map::furn(), furniture, input_context::get_desc(), get_map, map::get_signage(), input_context::handle_input(), map::has_furn(), Character::has_trait(), left, LINE_OXOX, m, mvwprintz(), mvwputch(), catacurses::newwin(), int_id< T >::obj(), point_zero, ui_manager::redraw(), input_context::register_action(), right, seen_critter(), Character::sees(), string_format(), map::ter(), TERMX, TERMY, terrain, trait_ILLITERATE, u, catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by look_around().

◆ find_nearby_items()

std::vector< map_item_stack > game::find_nearby_items ( int  iRadius)
private

Definition at line 7202 of file game.cpp.

7203{
7204 std::map<std::string, map_item_stack> temp_items;
7205 std::vector<map_item_stack> ret;
7206 std::vector<std::string> item_order;
7207
7208 if( u.is_blind() ) {
7209 return ret;
7210 }
7211
7212 for( auto &points_p_it : closest_points_first( u.pos(), iRadius ) ) {
7213 if( points_p_it.y >= u.posy() - iRadius && points_p_it.y <= u.posy() + iRadius &&
7214 u.sees( points_p_it ) &&
7215 m.sees_some_items( points_p_it, u ) ) {
7216
7217 for( auto &elem : m.i_at( points_p_it ) ) {
7218 const std::string name = elem.tname();
7219 const tripoint relative_pos = points_p_it - u.pos();
7220
7221 if( std::find( item_order.begin(), item_order.end(), name ) == item_order.end() ) {
7222 item_order.push_back( name );
7223 temp_items[name] = map_item_stack( &elem, relative_pos );
7224 } else {
7225 temp_items[name].add_at_pos( &elem, relative_pos );
7226 }
7227 }
7228 }
7229 }
7230
7231 for( auto &elem : item_order ) {
7232 ret.push_back( temp_items[elem] );
7233 }
7234
7235 return ret;
7236}
bool is_blind() const
Returns true if the player isn't able to see.
Definition: character.cpp:6357
std::vector< coords::coord_point< Point, Origin, Scale > > closest_points_first(const coords::coord_point< Point, Origin, Scale > &loc, int min_dist, int max_dist)
Definition: coordinates.h:596

References closest_points_first(), detail::find(), map::i_at(), Character::is_blind(), m, om_direction::name(), Character::pos(), Character::posy(), cata::hash64_detail::ret, Character::sees(), map::sees_some_items(), and u.

Referenced by list_items_monsters().

◆ find_npc()

npc * game::find_npc ( character_id  id)

Find the npc with the given ID.

Returns NULL if the npc could not be found. Searches all loaded overmaps.

Definition at line 1955 of file game.cpp.

1956{
1957 return overmap_buffer.find_npc( id ).get();
1958}

References overmapbuffer::find_npc(), and overmap_buffer.

Referenced by critter_by_id().

◆ find_or_make_stairs()

cata::optional< tripoint > game::find_or_make_stairs ( map mp,
int  z_after,
bool &  rope_ladder,
bool  peeking 
)

Returns the other end of the stairs (if any).

May query, affect u etc.

Definition at line 10955 of file game.cpp.

10957{
10958 const int omtilesz = SEEX * 2;
10959 real_coords rc( m.getabs( point( u.posx(), u.posy() ) ) );
10960 tripoint omtile_align_start( m.getlocal( rc.begin_om_pos() ), z_after );
10961 tripoint omtile_align_end( omtile_align_start + point( -1 + omtilesz, -1 + omtilesz ) );
10962
10963 // Try to find the stairs.
10965 int best = INT_MAX;
10966 const int movez = z_after - get_levz();
10967 const bool going_down_1 = movez == -1;
10968 const bool going_up_1 = movez == 1;
10969 // If there are stairs on the same x and y as we currently are, use those
10970 if( going_down_1 && mp.has_flag( TFLAG_GOES_UP, u.pos() + tripoint_below ) ) {
10971 stairs.emplace( u.pos() + tripoint_below );
10972 }
10973 if( going_up_1 && mp.has_flag( TFLAG_GOES_DOWN, u.pos() + tripoint_above ) ) {
10974 stairs.emplace( u.pos() + tripoint_above );
10975 }
10976 // We did not find stairs directly above or below, so search the map for them
10977 if( !stairs.has_value() ) {
10978 for( const tripoint &dest : m.points_in_rectangle( omtile_align_start, omtile_align_end ) ) {
10979 if( rl_dist( u.pos(), dest ) <= best &&
10980 ( ( going_down_1 && mp.has_flag( TFLAG_GOES_UP, dest ) ) ||
10981 ( going_up_1 && ( mp.has_flag( TFLAG_GOES_DOWN, dest ) ||
10982 mp.ter( dest ) == t_manhole_cover ) ) ||
10983 ( ( movez == 2 || movez == -2 ) && mp.ter( dest ) == t_elevator ) ) ) {
10984 stairs.emplace( dest );
10985 best = rl_dist( u.pos(), dest );
10986 }
10987 }
10988 }
10989
10990 if( stairs.has_value() ) {
10991 if( Creature *blocking_creature = critter_at( stairs.value() ) ) {
10992 npc *guy = dynamic_cast<npc *>( blocking_creature );
10993 monster *mon = dynamic_cast<monster *>( blocking_creature );
10994 bool would_move = ( guy && !guy->is_enemy() ) || ( mon && mon->friendly == -1 );
10995 bool can_displace = find_empty_spot_nearby( *stairs ).has_value();
10996 std::string cr_name = blocking_creature->get_name();
10997 std::string msg;
10998 if( guy ) {
10999 //~ %s is the name of hostile NPC
11000 msg = string_format( _( "%s is in the way!" ), cr_name );
11001 } else {
11002 //~ %s is some monster
11003 msg = string_format( _( "There's a %s in the way!" ), cr_name );
11004 }
11005
11006 if( ( peeking && !would_move ) || !can_displace || ( !would_move && !query_yn(
11007 //~ %s is a warning about monster/hostile NPC in the way, e.g. "There's a zombie in the way!"
11008 _( "%s Attempt to push past? You may have to fight your way back up." ), msg ) ) ) {
11009 add_msg( msg );
11010 return cata::nullopt;
11011 }
11012 }
11013 return stairs;
11014 }
11015
11016 // No stairs found! Try to make some
11017 rope_ladder = false;
11018 stairs.emplace( u.pos() );
11019 stairs->z = z_after;
11020 // Check the destination area for lava.
11021 if( mp.ter( *stairs ) == t_lava ) {
11022 if( movez < 0 &&
11023 !query_yn(
11024 _( "There is a LOT of heat coming out of there, even the stairs have melted away. Jump down? You won't be able to get back up." ) ) ) {
11025 return cata::nullopt;
11026 } else if( movez > 0 &&
11027 !query_yn(
11028 _( "There is a LOT of heat coming out of there. Push through the half-molten rocks and ascend? You will not be able to get back down." ) ) ) {
11029 return cata::nullopt;
11030 }
11031
11032 return stairs;
11033 }
11034
11035 if( movez > 0 ) {
11036 if( !mp.has_flag( "GOES_DOWN", *stairs ) ) {
11037 if( !query_yn( _( "You may be unable to return back down these stairs. Continue up?" ) ) ) {
11038 return cata::nullopt;
11039 }
11040 }
11041 // Manhole covers need this to work
11042 // Maybe require manhole cover here and fail otherwise?
11043 return stairs;
11044 }
11045
11046 if( mp.impassable( *stairs ) ) {
11047 popup( _( "Halfway down, the way down becomes blocked off." ) );
11048 return cata::nullopt;
11049 }
11050
11051 if( u.has_trait( trait_id( "WEB_RAPPEL" ) ) ) {
11052 if( query_yn( _( "There is a sheer drop halfway down. Web-descend?" ) ) ) {
11053 rope_ladder = true;
11054 if( ( rng( 4, 8 ) ) < u.get_skill_level( skill_dodge ) ) {
11055 add_msg( _( "You attach a web and dive down headfirst, flipping upright and landing on your feet." ) );
11056 } else {
11057 add_msg( _( "You securely web up and work your way down, lowering yourself safely." ) );
11058 }
11059 } else {
11060 return cata::nullopt;
11061 }
11062 } else if( u.has_trait( trait_VINES2 ) || u.has_trait( trait_VINES3 ) ) {
11063 if( query_yn( _( "There is a sheer drop halfway down. Use your vines to descend?" ) ) ) {
11064 if( u.has_trait( trait_VINES2 ) ) {
11065 if( query_yn( _( "Detach a vine? It'll hurt, but you'll be able to climb back up…" ) ) ) {
11066 rope_ladder = true;
11067 add_msg( m_bad, _( "You descend on your vines, though leaving a part of you behind stings." ) );
11068 u.mod_pain( 5 );
11069 u.apply_damage( nullptr, bodypart_id( "torso" ), 5 );
11070 u.mod_stored_nutr( 10 );
11071 u.mod_thirst( 10 );
11072 } else {
11073 add_msg( _( "You gingerly descend using your vines." ) );
11074 }
11075 } else {
11076 add_msg( _( "You effortlessly lower yourself and leave a vine rooted for future use." ) );
11077 rope_ladder = true;
11078 u.mod_stored_nutr( 10 );
11079 u.mod_thirst( 10 );
11080 }
11081 } else {
11082 return cata::nullopt;
11083 }
11084 } else if( u.has_amount( itype_grapnel, 1 ) ) {
11085 if( query_yn( _( "There is a sheer drop halfway down. Climb your grappling hook down?" ) ) ) {
11086 rope_ladder = true;
11088 } else {
11089 return cata::nullopt;
11090 }
11091 } else if( u.has_amount( itype_rope_30, 1 ) ) {
11092 if( query_yn( _( "There is a sheer drop halfway down. Climb your rope down?" ) ) ) {
11093 rope_ladder = true;
11095 } else {
11096 return cata::nullopt;
11097 }
11098 } else if( !query_yn( _( "There is a sheer drop halfway down. Jump?" ) ) ) {
11099 return cata::nullopt;
11100 }
11101
11102 return stairs;
11103}
int_id< body_part_type > bodypart_id
Definition: bodypart.h:23
void apply_damage(Creature *source, bodypart_id hurt, int dam, bool bypass_med=false) override
Actually hurt the player, hurts a body_part directly, no armor reduction.
Definition: character.cpp:8421
std::list< item > use_amount(itype_id it, int quantity, const std::function< bool(const item &)> &filter=return_true< item >)
Definition: character.cpp:9640
virtual void mod_thirst(int nthirst)
Definition: character.cpp:4430
virtual void mod_stored_nutr(int nnutr)
Definition: character.cpp:4320
int get_skill_level(const skill_id &ident) const
Definition: character.cpp:3359
T & emplace(Args &&... args)
Definition: optional.h:143
constexpr bool has_value() const noexcept
Definition: optional.h:120
tripoint getlocal(const tripoint &p) const
Inverse of getabs.
Definition: map.cpp:8079
bool impassable(const tripoint &p) const
Definition: map.cpp:1790
tripoint_range< tripoint > points_in_rectangle(const tripoint &from, const tripoint &to) const
Definition: map.cpp:8412
bool is_enemy() const
Definition: npc.cpp:2040
void mod_pain(int npain) override
Modifies a pain value by player traits before passing it to Creature::mod_pain()
Definition: player.cpp:987
static const trait_id trait_VINES2("VINES2")
static const skill_id skill_dodge("dodge")
static cata::optional< tripoint > find_empty_spot_nearby(const tripoint &pos)
Definition: game.cpp:10491
static const itype_id itype_rope_30("rope_30")
static const itype_id itype_grapnel("grapnel")
static const trait_id trait_VINES3("VINES3")
ter_id t_manhole_cover
Definition: mapdata.cpp:720
ter_id t_lava
Definition: mapdata.cpp:695
ter_id t_elevator
Definition: mapdata.cpp:723
@ TFLAG_GOES_DOWN
Definition: mapdata.h:308
@ TFLAG_GOES_UP
Definition: mapdata.h:309
static constexpr nullopt_t nullopt
Definition: optional.h:22
static constexpr tripoint tripoint_below
Definition: point.h:295
static constexpr tripoint tripoint_above
Definition: point.h:294

References _, add_msg(), Character::apply_damage(), real_coords::begin_om_pos(), critter_at(), cata::optional< T >::emplace(), find_empty_spot_nearby(), monster::friendly, get_levz(), Character::get_skill_level(), map::getabs(), map::getlocal(), visitable< T >::has_amount(), map::has_flag(), Character::has_trait(), cata::optional< T >::has_value(), map::impassable(), npc::is_enemy(), itype_grapnel, itype_rope_30, m, m_bad, player::mod_pain(), Character::mod_stored_nutr(), Character::mod_thirst(), cata::nullopt, map::points_in_rectangle(), popup(), Character::pos(), Character::posx(), Character::posy(), query_yn(), rl_dist(), rng(), SEEX, skill_dodge, string_format(), t_elevator, t_lava, t_manhole_cover, map::ter(), TFLAG_GOES_DOWN, TFLAG_GOES_UP, trait_VINES2, trait_VINES3, tripoint_above, tripoint_below, u, Character::use_amount(), and cata::optional< T >::value().

Referenced by vertical_move().

◆ fling_creature()

void game::fling_creature ( Creature c,
const units::angle dir,
float  flvel,
bool  controlled = false,
bool  suppress_map_update = false 
)

Flings the input creature in the given direction.

Definition at line 10316 of file game.cpp.

10318{
10319 if( c == nullptr ) {
10320 debugmsg( "game::fling_creature invoked on null target" );
10321 return;
10322 }
10323
10324 if( c->is_dead_state() ) {
10325 // Flinging a corpse causes problems, don't enable without testing
10326 return;
10327 }
10328
10329 if( c->is_hallucination() ) {
10330 // Don't fling hallucinations
10331 return;
10332 }
10333
10334 int steps = 0;
10335 bool thru = true;
10336 const bool is_u = ( c == &u );
10337 // Don't animate critters getting bashed if animations are off
10338 const bool animate = is_u || get_option<bool>( "ANIMATIONS" );
10339
10340 player *p = dynamic_cast<player *>( c );
10341
10342 tileray tdir( dir );
10343 int range = flvel / 10;
10344 tripoint pt = c->pos();
10345 while( range > 0 ) {
10346 c->underwater = false;
10347 // TODO: Check whenever it is actually in the viewport
10348 // or maybe even just redraw the changed tiles
10349 bool seen = is_u || u.sees( *c ); // To avoid redrawing when not seen
10350 tdir.advance();
10351 pt.x = c->posx() + tdir.dx();
10352 pt.y = c->posy() + tdir.dy();
10353 float force = 0;
10354
10355 if( monster *const mon_ptr = critter_at<monster>( pt ) ) {
10356 monster &critter = *mon_ptr;
10357 // Approximate critter's "stopping power" with its max hp
10358 force = std::min<float>( 1.5f * critter.type->hp, flvel );
10359 const int damage = rng( force, force * 2.0f ) / 6;
10360 c->impact( damage, pt );
10361 // Multiply zed damage by 6 because no body parts
10362 const int zed_damage = std::max( 0,
10363 ( damage - critter.get_armor_bash( bodypart_id( "torso" ) ) ) * 6 );
10364 // TODO: Pass the "flinger" here - it's not the flung critter that deals damage
10365 critter.apply_damage( c, bodypart_id( "torso" ), zed_damage );
10366 critter.check_dead_state();
10367 if( !critter.is_dead() ) {
10368 thru = false;
10369 }
10370 } else if( m.impassable( pt ) ) {
10371 if( !m.veh_at( pt ).obstacle_at_part() ) {
10372 force = std::min<float>( m.bash_strength( pt ), flvel );
10373 } else {
10374 // No good way of limiting force here
10375 // Keep it 1 less than maximum to make the impact hurt
10376 // but to keep the target flying after it
10377 force = flvel - 1;
10378 }
10379 const int damage = rng( force, force * 2.0f ) / 9;
10380 c->impact( damage, pt );
10381 if( m.is_bashable( pt ) ) {
10382 // Only go through if we successfully make the tile passable
10383 m.bash( pt, flvel );
10384 thru = m.passable( pt );
10385 } else {
10386 thru = false;
10387 }
10388 }
10389
10390 // If the critter dies during flinging, moving it around causes debugmsgs
10391 if( c->is_dead_state() ) {
10392 return;
10393 }
10394
10395 flvel -= force;
10396 if( thru ) {
10397 if( p != nullptr ) {
10398 if( p->in_vehicle ) {
10399 m.unboard_vehicle( p->pos() );
10400 }
10401 // If we're flinging the player around, make sure the map stays centered on them.
10402 if( is_u && !suppress_map_update ) {
10403 update_map( pt.x, pt.y );
10404 } else {
10405 p->setpos( pt );
10406 }
10407 } else if( !critter_at( pt ) ) {
10408 // Dying monster doesn't always leave an empty tile (blob spawning etc.)
10409 // Just don't setpos if it happens - next iteration will do so
10410 // or the monster will stop a tile before the unpassable one
10411 c->setpos( pt );
10412 }
10413 } else {
10414 // Don't zero flvel - count this as slamming both the obstacle and the ground
10415 // although at lower velocity
10416 break;
10417 }
10418 range--;
10419 steps++;
10420 if( animate && ( seen || u.sees( *c ) ) ) {
10424 }
10425 }
10426
10427 // Fall down to the ground - always on the last reached tile
10428 if( !m.has_flag( "SWIMMABLE", c->pos() ) ) {
10429 const trap_id trap_under_creature = m.tr_at( c->pos() ).loadid;
10430 // Didn't smash into a wall or a floor so only take the fall damage
10431 if( thru && trap_under_creature == tr_ledge ) {
10432 m.creature_on_trap( *c, false );
10433 } else {
10434 // Fall on ground
10435 int force = rng( flvel, flvel * 2 ) / 9;
10436 if( controlled ) {
10437 force = std::max( force / 2 - 5, 0 );
10438 }
10439 if( force > 0 ) {
10440 int dmg = c->impact( force, c->pos() );
10441 // TODO: Make landing damage the floor
10442 m.bash( c->pos(), dmg / 4, false, false, false );
10443 }
10444 // Always apply traps to creature i.e. bear traps, tele traps etc.
10445 m.creature_on_trap( *c, false );
10446 }
10447 } else {
10448 c->underwater = true;
10449 if( is_u ) {
10450 if( controlled ) {
10451 add_msg( _( "You dive into water." ) );
10452 } else {
10453 add_msg( m_warning, _( "You fall into water." ) );
10454 }
10455 }
10456 }
10457}
void setpos(const tripoint &p) override
Definition: character.h:799
void check_dead_state()
This function checks the creatures is_dead_state and (if true) calls die.
Definition: creature.cpp:1836
point update_map(player &p)
Definition: game.cpp:11182
int bash_strength(const tripoint &p, bool allow_floor=false) const
Returns max_str of the furniture or terrain at p.
Definition: map.cpp:2444
bash_results bash(const tripoint &p, int str, bool silent=false, bool destroy=false, bool bash_floor=false, const vehicle *bashing_vehicle=nullptr)
Returns a pair where first is whether anything was smashed and second is if it was destroyed.
Definition: map.cpp:3506
void unboard_vehicle(const vpart_reference &, Character *passenger, bool dead_passenger=false)
Definition: map.cpp:1076
bool is_bashable(const tripoint &p, bool allow_floor=false) const
Returns true if there is a bashable vehicle part or the furn/terrain is bashable at p.
Definition: map.cpp:2409
void creature_on_trap(Creature &critter, bool may_avoid=true)
Apply trap effects to the creature, similar to creature_in_field.
Definition: map.cpp:8285
bool passable(const tripoint &p) const
Definition: map.cpp:1795
int get_armor_bash(bodypart_id bp) const override
Definition: monster.cpp:1855
bool is_dead() const
Definition: monster.cpp:2753
void apply_damage(Creature *source, bodypart_id bp, int dam, bool bypass_med=false) override
Definition: monster.cpp:1636
cata::optional< vpart_reference > obstacle_at_part() const
Definition: vehicle.cpp:2493
static const trap_str_id tr_ledge("tr_ledge")
void redraw_invalidated()
Definition: ui_manager.cpp:290
int hp
Definition: mtype.h:267
trap_id loadid
Definition: trap.h:88
int y
Definition: point.h:151
int x
Definition: point.h:150

References _, add_msg(), tileray::advance(), monster::apply_damage(), map::bash(), map::bash_strength(), c, Creature::check_dead_state(), map::creature_on_trap(), critter_at(), debugmsg, tileray::dx(), tileray::dy(), monster::get_armor_bash(), map::has_flag(), mtype::hp, map::impassable(), Character::in_vehicle, invalidate_main_ui_adaptor(), map::is_bashable(), monster::is_dead(), trap::loadid, m, m_warning, optional_vpart_position::obstacle_at_part(), map::passable(), Character::pos(), ui_manager::redraw_invalidated(), refresh_display(), rng(), Character::sees(), Character::setpos(), map::tr_at(), tr_ledge, monster::type, u, map::unboard_vehicle(), update_map(), map::veh_at(), tripoint::x, and tripoint::y.

Referenced by moving_vehicle_dismount().

◆ forced_door_closing()

bool game::forced_door_closing ( const tripoint p,
const ter_id door_type,
int  bash_dmg 
)

Definition at line 5299 of file game.cpp.

5300{
5301 // TODO: Z
5302 const int &x = p.x;
5303 const int &y = p.y;
5304 const std::string &door_name = door_type.obj().name();
5305 // sed when player/monsters are knocked back and when moving items out of the way
5306 point kb( x, y );
5307 const auto valid_location = [&]( const tripoint & p ) {
5308 return g->is_empty( p );
5309 };
5311 valid_location ) ) {
5312 kb.x = -pos->x + x + x;
5313 kb.y = -pos->y + y + y;
5314 }
5315 const tripoint kbp( kb, p.z );
5316 if( kbp == p ) {
5317 // can't pushback any creatures anywhere, that means the door can't close.
5318 return false;
5319 }
5320 const bool can_see = u.sees( tripoint( x, y, p.z ) );
5321 player *npc_or_player = critter_at<player>( tripoint( x, y, p.z ), false );
5322 if( npc_or_player != nullptr ) {
5323 if( bash_dmg <= 0 ) {
5324 return false;
5325 }
5326 if( npc_or_player->is_npc() && can_see ) {
5327 add_msg( _( "The %1$s hits the %2$s." ), door_name, npc_or_player->name );
5328 } else if( npc_or_player->is_player() ) {
5329 add_msg( m_bad, _( "The %s hits you." ), door_name );
5330 }
5331 if( npc_or_player->activity ) {
5332 npc_or_player->cancel_activity();
5333 }
5334 // TODO: make the npc angry?
5335 npc_or_player->hitall( bash_dmg, 0, nullptr );
5336 knockback( kbp, p, std::max( 1, bash_dmg / 10 ), -1, 1 );
5337 // TODO: perhaps damage/destroy the gate
5338 // if the npc was really big?
5339 }
5340 if( monster *const mon_ptr = critter_at<monster>( p ) ) {
5341 monster &critter = *mon_ptr;
5342 if( bash_dmg <= 0 ) {
5343 return false;
5344 }
5345 if( can_see ) {
5346 add_msg( _( "The %1$s hits the %2$s." ), door_name, critter.name() );
5347 }
5348 if( critter.type->size <= MS_SMALL ) {
5349 critter.die_in_explosion( nullptr );
5350 } else {
5351 critter.apply_damage( nullptr, bodypart_id( "torso" ), bash_dmg );
5352 critter.check_dead_state();
5353 }
5354 if( !critter.is_dead() && critter.type->size >= MS_HUGE ) {
5355 // big critters simply prevent the gate from closing
5356 // TODO: perhaps damage/destroy the gate
5357 // if the critter was really big?
5358 return false;
5359 }
5360 if( !critter.is_dead() ) {
5361 // Still alive? Move the critter away so the door can close
5362 knockback( kbp, p, std::max( 1, bash_dmg / 10 ), -1, 1 );
5363 if( critter_at( p ) ) {
5364 return false;
5365 }
5366 }
5367 }
5368 if( const optional_vpart_position vp = m.veh_at( p ) ) {
5369 if( bash_dmg <= 0 ) {
5370 return false;
5371 }
5372 vp->vehicle().damage( vp->part_index(), bash_dmg );
5373 if( m.veh_at( p ) ) {
5374 // Check again in case all parts at the door tile
5375 // have been destroyed, if there is still a vehicle
5376 // there, the door can not be closed
5377 return false;
5378 }
5379 }
5380 if( bash_dmg < 0 && !m.i_at( point( x, y ) ).empty() ) {
5381 return false;
5382 }
5383 if( bash_dmg == 0 ) {
5384 for( auto &elem : m.i_at( point( x, y ) ) ) {
5385 if( elem.made_of( LIQUID ) ) {
5386 // Liquids are OK, will be destroyed later
5387 continue;
5388 } else if( elem.volume() < 250_ml ) {
5389 // Dito for small items, will be moved away
5390 continue;
5391 }
5392 // Everything else prevents the door from closing
5393 return false;
5394 }
5395 }
5396
5397 m.ter_set( point( x, y ), door_type );
5398 if( m.has_flag( "NOITEM", point( x, y ) ) ) {
5399 map_stack items = m.i_at( point( x, y ) );
5400 for( map_stack::iterator it = items.begin(); it != items.end(); ) {
5401 if( it->made_of( LIQUID ) ) {
5402 it = items.erase( it );
5403 continue;
5404 }
5405 if( it->made_of( material_id( "glass" ) ) && one_in( 2 ) ) {
5406 if( can_see ) {
5407 add_msg( m_warning, _( "A %s shatters!" ), it->tname() );
5408 } else {
5409 add_msg( m_warning, _( "Something shatters!" ) );
5410 }
5411 it = items.erase( it );
5412 continue;
5413 }
5414 m.add_item_or_charges( kbp, *it );
5415 it = items.erase( it );
5416 }
5417 }
5418 return true;
5419}
int hitall(int dam, int vary, Creature *source)
Harms all body parts for dam, with armor reduction.
Definition: character.cpp:8689
void knockback(const tripoint &s, const tripoint &t, int force, int stun, int dam_mult)
Definition: game.cpp:4586
iterator erase(const_iterator it) override
Definition: map.cpp:148
bool ter_set(const tripoint &p, const ter_id &new_terrain)
Definition: map.cpp:1634
void die_in_explosion(Creature *source)
Definition: monster.cpp:1650
bool is_npc() const override
Definition: player.h:122
bool is_player() const override
Definition: player.h:105
@ MS_SMALL
Definition: creature.h:59
@ MS_HUGE
Definition: creature.h:62
@ LIQUID
Definition: enums.h:175
cata::optional< tripoint > random_point(const map &m, const std::function< bool(const tripoint &)> &predicate)
Same as other random_point with a range enclosing all valid points of the map.
std::string name() const
Definition: mapdata.cpp:511
m_size size
Definition: mtype.h:259

References _, Character::activity, map::add_item_or_charges(), add_msg(), monster::apply_damage(), item_stack::begin(), Character::cancel_activity(), Creature::check_dead_state(), critter_at(), monster::die_in_explosion(), item_stack::end(), map_stack::erase(), g, map::has_flag(), Character::hitall(), map::i_at(), monster::is_dead(), player::is_npc(), player::is_player(), knockback(), LIQUID, m, m_bad, m_warning, MS_HUGE, MS_SMALL, Character::name, map_data_common_t::name(), monster::name(), int_id< T >::obj(), one_in(), map::points_in_radius(), random_point(), Character::sees(), mtype::size, map::ter_set(), monster::type, u, map::veh_at(), point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

◆ gametype()

special_game_id game::gametype ( ) const

Definition at line 629 of file game.cpp.

630{
631 return gamemode ? gamemode->id() : SGAME_NULL;
632}
@ SGAME_NULL
Definition: enums.h:93

References gamemode, and SGAME_NULL.

◆ get_creature_if()

Creature * game::get_creature_if ( const std::function< bool(const Creature &)> &  pred)

Returns a creature matching a predicate.

Only living (not dead) creatures are checked. Returns nullptr if no creature matches the predicate. There is no guarantee which creature is returned when several creatures match.

Definition at line 12529 of file game.cpp.

12530{
12531 for( Creature &critter : all_creatures() ) {
12532 if( pred( critter ) ) {
12533 return &critter;
12534 }
12535 }
12536 return nullptr;
12537}

References all_creatures().

◆ get_creatures_if()

std::vector< Creature * > game::get_creatures_if ( const std::function< bool(const Creature &)> &  pred)

Returns all creatures matching a predicate.

Only living ( not dead ) creatures are checked ( and returned ). Returned pointers are never null.

Definition at line 12439 of file game.cpp.

12441{
12442 std::vector<Creature *> result;
12443 for( Creature &critter : all_creatures() ) {
12444 if( pred( critter ) ) {
12445 result.push_back( &critter );
12446 }
12447 }
12448 return result;
12449}

References all_creatures().

◆ get_cur_om()

overmap & game::get_cur_om ( ) const

The overmap which contains the center submap of the reality bubble.

Definition at line 12419 of file game.cpp.

12420{
12421 // The player is located in the middle submap of the map.
12423 const tripoint pos_om = sm_to_om_copy( sm );
12424 // TODO: fix point types
12425 return overmap_buffer.get( point_abs_om( pos_om.xy() ) );
12426}
tripoint get_abs_sub() const
return abs_sub
Definition: map.cpp:8089
overmap & get(const point_abs_om &)
Uses overmap coordinates, that means x and y are directly compared with the position of the overmap.
point sm_to_om_copy(const point &p)
coords::coord_point< point, coords::origin::abs, coords::om > point_abs_om
Definition: coordinates.h:483
static constexpr int HALF_MAPSIZE
constexpr scale sm
Definition: coordinates.h:31

References overmapbuffer::get(), map::get_abs_sub(), HALF_MAPSIZE, m, overmap_buffer, coords::sm, sm_to_om_copy(), and tripoint::xy().

Referenced by start_game().

◆ get_dangerous_tile()

std::vector< std::string > game::get_dangerous_tile ( const tripoint dest_loc) const

Definition at line 9273 of file game.cpp.

9274{
9275 std::vector<std::string> harmful_stuff;
9276 const auto fields_here = m.field_at( u.pos() );
9277 for( const auto &e : m.field_at( dest_loc ) ) {
9278 // warn before moving into a dangerous field except when already standing within a similar field
9279 if( u.is_dangerous_field( e.second ) && fields_here.find_field( e.first ) == nullptr ) {
9280 harmful_stuff.push_back( e.second.name() );
9281 }
9282 }
9283
9284 if( !u.is_blind() ) {
9285 const trap &tr = m.tr_at( dest_loc );
9286 const bool boardable = static_cast<bool>( m.veh_at( dest_loc ).part_with_feature( "BOARDABLE",
9287 true ) );
9288 // HACK: Hack for now, later ledge should stop being a trap
9289 // Note: in non-z-level mode, ledges obey different rules and so should be handled as regular traps
9290 if( tr.loadid == tr_ledge && m.has_zlevels() ) {
9291 if( !boardable ) {
9292 harmful_stuff.emplace_back( tr.name() );
9293 }
9294 } else if( tr.can_see( dest_loc, u ) && !tr.is_benign() && !boardable ) {
9295 harmful_stuff.emplace_back( tr.name() );
9296 }
9297
9298 static const std::set< body_part > sharp_bps = {
9301 };
9302
9303 const auto sharp_bp_check = [this]( body_part bp ) {
9304 return u.immune_to( bp, { DT_CUT, 10 } );
9305 };
9306
9307 if( m.has_flag( "ROUGH", dest_loc ) && !m.has_flag( "ROUGH", u.pos() ) && !boardable &&
9308 ( u.get_armor_bash( bodypart_id( "foot_l" ) ) < 5 ||
9309 u.get_armor_bash( bodypart_id( "foot_r" ) ) < 5 ) ) {
9310 harmful_stuff.emplace_back( m.name( dest_loc ) );
9311 } else if( m.has_flag( "SHARP", dest_loc ) && !m.has_flag( "SHARP", u.pos() ) && !( u.in_vehicle ||
9312 m.veh_at( dest_loc ) ) &&
9313 u.dex_cur < 78 && !std::all_of( sharp_bps.begin(), sharp_bps.end(), sharp_bp_check ) ) {
9314 harmful_stuff.emplace_back( m.name( dest_loc ) );
9315 }
9316
9317 }
9318
9319 return harmful_stuff;
9320}
@ bp_foot_l
Definition: bodypart.h:50
@ bp_leg_r
Definition: bodypart.h:49
@ bp_eyes
Definition: bodypart.h:42
@ bp_hand_l
Definition: bodypart.h:46
@ bp_arm_l
Definition: bodypart.h:44
@ bp_leg_l
Definition: bodypart.h:48
@ bp_hand_r
Definition: bodypart.h:47
@ bp_head
Definition: bodypart.h:41
@ bp_torso
Definition: bodypart.h:40
@ bp_mouth
Definition: bodypart.h:43
@ bp_foot_r
Definition: bodypart.h:51
@ bp_arm_r
Definition: bodypart.h:45
int dex_cur
Definition: character.h:247
int get_armor_bash(bodypart_id bp) const override
Returns overall bashing resistance for the body_part.
Definition: character.cpp:6985
bool is_dangerous_field(const field_entry &entry) const
Returns true if the given field entry is dangerous to us.
Definition: creature.cpp:196
const field & field_at(const tripoint &p) const
Get the fields that are here.
Definition: map.cpp:5277
bool has_zlevels() const
Definition: map.h:1655
cata::optional< vpart_reference > part_with_feature(const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2481
bool immune_to(body_part bp, damage_unit dam) const
Check if a given body part is immune to a given damage type.
Definition: player.cpp:970
@ DT_CUT
Definition: damage.h:25
Definition: trap.h:86
std::string name() const
Definition: trap.cpp:177
bool can_see(const tripoint &pos, const Character &p) const
Can player/npc p see this kind of trap, either by their memory (they known there is the trap) or by t...
Definition: trap.cpp:223
bool is_benign() const
If true, this is not really a trap and there won't be any safety queries before stepping onto it (e....
Definition: trap.h:159

References bp_arm_l, bp_arm_r, bp_eyes, bp_foot_l, bp_foot_r, bp_hand_l, bp_hand_r, bp_head, bp_leg_l, bp_leg_r, bp_mouth, bp_torso, trap::can_see(), Character::dex_cur, DT_CUT, map::field_at(), Character::get_armor_bash(), map::has_flag(), map::has_zlevels(), player::immune_to(), Character::in_vehicle, trap::is_benign(), Character::is_blind(), Creature::is_dangerous_field(), trap::loadid, m, trap::name(), map::name(), optional_vpart_position::part_with_feature(), Character::pos(), map::tr_at(), tr_ledge, u, and map::veh_at().

Referenced by is_dangerous_tile(), prompt_dangerous_tile(), and walk_move().

◆ get_fishable_locations()

std::unordered_set< tripoint > game::get_fishable_locations ( int  distance,
const tripoint fish_pos 
)

Get the contiguous fishable locations starting at fish_pos, out to the specificed distance.

Parameters
distanceDistance around the fish_pos to examine for contiguous fishable locations.
fish_posThe location being fished.
Returns
A set of locations representing the valid contiguous fishable locations.

Definition at line 3973 of file game.cpp.

3974{
3975 // We're going to get the contiguous fishable terrain starting at
3976 // the provided fishing location (e.g. where a line was cast or a fish
3977 // trap was set), and then check whether or not fishable monsters are
3978 // actually in those locations. This will help us ensure that we're
3979 // getting our fish from the location that we're ACTUALLY fishing,
3980 // rather than just somewhere in the vicinity.
3981
3982 std::unordered_set<tripoint> visited;
3983
3984 const tripoint fishing_boundary_min( fish_pos + point( -distance, -distance ) );
3985 const tripoint fishing_boundary_max( fish_pos + point( distance, distance ) );
3986
3987 const inclusive_cuboid<tripoint> fishing_boundaries(
3988 fishing_boundary_min, fishing_boundary_max );
3989
3990 const auto get_fishable_terrain = [&]( tripoint starting_point,
3991 std::unordered_set<tripoint> &fishable_terrain ) {
3992 std::queue<tripoint> to_check;
3993 to_check.push( starting_point );
3994 while( !to_check.empty() ) {
3995 const tripoint current_point = to_check.front();
3996 to_check.pop();
3997
3998 // We've been here before, so bail.
3999 if( visited.find( current_point ) != visited.end() ) {
4000 continue;
4001 }
4002
4003 // This point is out of bounds, so bail.
4004 if( !fishing_boundaries.contains( current_point ) ) {
4005 continue;
4006 }
4007
4008 // Mark this point as visited.
4009 visited.emplace( current_point );
4010
4011 if( m.has_flag( "FISHABLE", current_point ) ) {
4012 fishable_terrain.emplace( current_point );
4013 to_check.push( current_point + point_south );
4014 to_check.push( current_point + point_north );
4015 to_check.push( current_point + point_east );
4016 to_check.push( current_point + point_west );
4017 }
4018 }
4019 return;
4020 };
4021
4022 // Starting at the provided location, get our fishable terrain
4023 // and populate a set with those locations which we'll then use
4024 // to determine if any fishable monsters are in those locations.
4025 std::unordered_set<tripoint> fishable_points;
4026 get_fishable_terrain( fish_pos, fishable_points );
4027
4028 return fishable_points;
4029}
static constexpr point point_west
Definition: point.h:282
static constexpr point point_south
Definition: point.h:280
static constexpr point point_north
Definition: point.h:276
static constexpr point point_east
Definition: point.h:278

References inclusive_cuboid< Tripoint, >::contains(), map::has_flag(), m, point_east, point_north, point_south, and point_west.

◆ get_fishable_monsters()

std::vector< monster * > game::get_fishable_monsters ( std::unordered_set< tripoint > &  fishable_locations)

Get the fishable monsters within the provided fishable locations.

Parameters
fishable_locationsA set of locations which are valid fishable terrain. Any fishable monsters are filtered by this collection to determine those which can actually be caught.
Returns
Fishable monsters within the specified fishable terrain.

Definition at line 4031 of file game.cpp.

4033{
4034 std::vector<monster *> unique_fish;
4035 for( monster &critter : all_monsters() ) {
4036 // If it is fishable...
4037 if( critter.has_flag( MF_FISHABLE ) ) {
4038 const tripoint critter_pos = critter.pos();
4039 // ...and it is in a fishable location.
4040 if( fishable_locations.find( critter_pos ) != fishable_locations.end() ) {
4041 unique_fish.push_back( &critter );
4042 }
4043 }
4044 }
4045
4046 return unique_fish;
4047}
@ MF_FISHABLE
Definition: mtype.h:142

References all_monsters(), and MF_FISHABLE.

◆ get_follower_list()

std::set< character_id > game::get_follower_list ( )

Get set of followers.

Definition at line 2052 of file game.cpp.

2053{
2054 return follower_ids;
2055}

References follower_ids.

◆ get_kill_tracker()

const kill_tracker & game::get_kill_tracker ( ) const

Definition at line 968 of file game.cpp.

969{
970 return *kill_tracker_ptr;
971}

References kill_tracker_ptr.

Referenced by cleanup_at_end(), death_screen(), handle_action(), and win().

◆ get_levx()

int game::get_levx ( ) const

The top left corner of the reality bubble (in submaps coordinates).

This is the same as map::abs_sub of the m map.

Definition at line 12404 of file game.cpp.

12405{
12406 return m.get_abs_sub().x;
12407}

References map::get_abs_sub(), m, and tripoint::x.

Referenced by create_starting_npcs(), load_npcs(), look_around(), save_cyborg(), spawn_hallucination(), vertical_move(), and vertical_shift().

◆ get_levy()

int game::get_levy ( ) const

Definition at line 12409 of file game.cpp.

12410{
12411 return m.get_abs_sub().y;
12412}

References map::get_abs_sub(), m, and tripoint::y.

Referenced by create_starting_npcs(), load_npcs(), look_around(), save_cyborg(), spawn_hallucination(), vertical_move(), and vertical_shift().

◆ get_levz()

◆ get_moves_since_last_save()

int game::get_moves_since_last_save ( ) const

Definition at line 7372 of file game.cpp.

7373{
7374 return moves_since_last_save;
7375}

References moves_since_last_save.

◆ get_npcs_if()

std::vector< npc * > game::get_npcs_if ( const std::function< bool(const npc &)> &  pred)

Definition at line 12451 of file game.cpp.

12452{
12453 std::vector<npc *> result;
12454 for( npc &guy : all_npcs() ) {
12455 if( pred( guy ) ) {
12456 result.push_back( &guy );
12457 }
12458 }
12459 return result;
12460}

References all_npcs().

Referenced by allies(), chat(), and validate_npc_followers().

◆ get_player_base_save_path()

std::string game::get_player_base_save_path ( ) const

Base path for saving player data.

Just add a suffix (unique for the thing you want to save) and use the resulting path. Example: save_ui_data(get_player_base_save_path()+".ui")

Definition at line 12539 of file game.cpp.

12540{
12541 return get_world_base_save_path() + "/" + base64_encode( u.name );
12542}
std::string base64_encode(const std::string &str)
std::string get_world_base_save_path() const
Base path for saving world data.
Definition: game.cpp:12544

References base64_encode(), get_world_base_save_path(), Character::name, and u.

Referenced by save_player_data().

◆ get_player_input()

input_context game::get_player_input ( std::string &  action)
private

Definition at line 237 of file handle_action.cpp.

238{
239 input_context ctxt;
240 if( uquit == QUIT_WATCH ) {
241 ctxt = input_context( "DEFAULTMODE" );
242 ctxt.set_iso( true );
243 // The list of allowed actions in death-cam mode in game::handle_action
244 // *INDENT-OFF*
245 for( const action_id id : {
258 } ) {
259 ctxt.register_action( action_ident( id ) );
260 }
261 // *INDENT-ON*
262 ctxt.register_action( "QUIT", to_translation( "Accept your fate" ) );
263 } else {
265 }
266
268
269 user_turn current_turn;
270
271
272 // Checking early if we will need to handle animations
273 // If we do not need to handle animations that will not change as long as the user has not selected an action
274 // and we can handle it like we are not animating.
275 weather_printable wPrint;
276 bool animate_weather = false;
277 bool animate_sct = false;
278 bool do_animations = [&]() {
279 if( get_option<bool>( "ANIMATIONS" ) ) {
280 const bool weather_has_anim = init_weather_anim( get_weather().weather_id, wPrint );
281
282 animate_weather = weather_has_anim && get_option<bool>( "ANIMATION_RAIN" );
283 animate_sct = !SCT.vSCT.empty() && uquit != QUIT_WATCH && get_option<bool>( "ANIMATION_SCT" );
284
285#if defined(TILES)
286 // Always animate, minimap and terrain may have animations to run
287 return true;
288#else
289 // Otherwise we need to see if we actually should animate.
290 // Minimap and Terrain never animate in !TILES
291 return animate_weather || animate_sct || uquit == QUIT_WATCH;
292#endif
293 }
294 return false;
295 }
296 ();
297
298 if( do_animations ) {
299 ctxt.set_timeout( 125 );
300
302 make_shared_fast<game::draw_callback_t>( [&]() {
303 if( animate_weather ) {
304 draw_weather( wPrint );
305 }
306 if( animate_sct ) {
307 draw_sct();
308 }
309 } );
310 add_draw_callback( animation_cb );
311 invalidate_main_ui_adaptor(); // We want to redraw at least once.
312
313 do {
314 if( animate_weather ) {
316 generate_weather_anim_frame( get_weather().weather_id, wPrint );
317 }
318 // don't bother calculating SCT if we won't show it
319 if( animate_sct ) {
321
323
324 //Check for creatures on all drawing positions and offset if necessary
325 for( auto iter = SCT.vSCT.rbegin(); iter != SCT.vSCT.rend(); ++iter ) {
326 const direction oCurDir = iter->getDirecton();
327 const int width = utf8_width( iter->getText() );
328 for( int i = 0; i < width; ++i ) {
329 tripoint tmp( iter->getPosX() + i, iter->getPosY(), get_levz() );
330 const Creature *critter = critter_at( tmp, true );
331
332 if( critter != nullptr && u.sees( *critter ) ) {
333 i = -1;
334 int iPos = iter->getStep() + iter->getStepOffset();
335 for( auto iter2 = iter; iter2 != SCT.vSCT.rend(); ++iter2 ) {
336 if( iter2->getDirecton() == oCurDir &&
337 iter2->getStep() + iter2->getStepOffset() <= iPos ) {
338 if( iter2->getType() == "hp" ) {
339 iter2->advanceStepOffset();
340 }
341
342 iter2->advanceStepOffset();
343 iPos = iter2->getStep() + iter2->getStepOffset();
344 }
345 }
346 }
347 }
348 }
349
350 // Stop animation when done
351 animate_sct = !SCT.vSCT.empty();
352 }
353 // We don't cache these checks as their result may change after 1st redraw
355 // TODO: we redraw *everything* just to animate a couple blinking dots
356 // on the minimap or a few tiles.
357 // This is far from ideal, and can probably be done much cheaper
358 // (update only part of the screen? draw static parts into a texture?)
360 }
361
362 std::unique_ptr<static_popup> deathcam_msg_popup;
363 if( uquit == QUIT_WATCH ) {
364 deathcam_msg_popup = std::make_unique<static_popup>();
365 deathcam_msg_popup
366 ->wait_message( c_red, _( "Press %s to accept your fate…" ), ctxt.get_desc( "QUIT" ) )
367 .on_top( true );
368 }
369
371 } while( handle_mouseview( ctxt, action ) && uquit != QUIT_WATCH
372 && ( action != "TIMEOUT" || !current_turn.has_timeout_elapsed() ) );
373 ctxt.reset_timeout();
374 } else {
377 SCT.vSCT.clear();
378
379 ctxt.set_timeout( 125 );
380 while( handle_mouseview( ctxt, action ) ) {
381 if( action == "TIMEOUT" && current_turn.has_timeout_elapsed() ) {
382 break;
383 }
384 }
385 ctxt.reset_timeout();
386 }
387
388 return ctxt;
389}
std::string action_ident(action_id act)
Lookup a unique string identifier for a given action ID.
Definition: action.cpp:67
action_id
Enumerates all discrete actions that can be performed by player.
Definition: action.h:22
@ ACTION_CENTER
Center the viewport on character.
Definition: action.h:77
@ ACTION_SHIFT_SW
Move viewport south-west.
Definition: action.h:89
@ ACTION_SHIFT_NW
Move viewport north-west.
Definition: action.h:93
@ ACTION_KEYBINDINGS
Display keybindings list.
Definition: action.h:257
@ ACTION_SHIFT_E
Move viewport east.
Definition: action.h:83
@ ACTION_TOGGLE_MAP_MEMORY
Toggle memorized tiles being shown.
Definition: action.h:75
@ ACTION_SHIFT_S
Move viewport south.
Definition: action.h:87
@ ACTION_SHIFT_SE
Move viewport south-east.
Definition: action.h:85
@ ACTION_LOOK
Toggle look mode.
Definition: action.h:119
@ ACTION_SHIFT_NE
Move viewport north-east.
Definition: action.h:81
@ ACTION_SHIFT_W
Move viewport west.
Definition: action.h:91
@ ACTION_SHIFT_N
Move viewport north.
Definition: action.h:79
bool terrain_requires_animation()
Definition: animation.cpp:1136
bool minimap_requires_animation()
Definition: animation.cpp:1127
void draw_sct()
Definition: animation.cpp:797
void draw_weather(const weather_printable &wPrint)
Definition: animation.cpp:756
void add_draw_callback(shared_ptr_fast< draw_callback_t > cb)
Definition: game.cpp:3386
bool handle_mouseview(input_context &ctxt, std::string &action)
Definition: game.cpp:2325
void set_timeout(int val)
Sets input polling timeout as appropriate for the current interface system.
Definition: input.cpp:1458
std::string get_desc(const std::string &action_descriptor, unsigned int max_limit=0, const input_event_filter &evt_filter=allow_all_keys) const
Get a description text for the key/other input method associated with the given action.
Definition: input.cpp:756
void register_action(const std::string &action_descriptor)
Register an action with this input context.
Definition: input.cpp:676
void set_iso(bool mode=true)
Definition: input.cpp:1429
void reset_timeout()
Definition: input.cpp:1463
std::vector< cSCT > vSCT
Definition: output.h:947
void advanceAllSteps()
Definition: output.cpp:1924
bool has_timeout_elapsed()
input_context get_default_mode_input_context()
Definition: game.cpp:2425
static bool init_weather_anim(const weather_type_id &wtype, weather_printable &wPrint)
static void generate_weather_anim_frame(const weather_type_id &wtype, weather_printable &wPrint)
direction
Definition: line.h:39
scrollingcombattext SCT
Definition: output.cpp:65
Weather drawing tracking.
Definition: weather.h:59
translation to_translation(const std::string &raw)
Shorthands for translation::to_translation.

References _, action, ACTION_CENTER, action_ident(), ACTION_KEYBINDINGS, ACTION_LOOK, ACTION_SHIFT_E, ACTION_SHIFT_N, ACTION_SHIFT_NE, ACTION_SHIFT_NW, ACTION_SHIFT_S, ACTION_SHIFT_SE, ACTION_SHIFT_SW, ACTION_SHIFT_W, ACTION_TOGGLE_MAP_MEMORY, add_draw_callback(), scrollingcombattext::advanceAllSteps(), c_red, critter_at(), draw_sct(), draw_weather(), generate_weather_anim_frame(), get_default_mode_input_context(), input_context::get_desc(), get_levz(), get_weather, handle_mouseview(), user_turn::has_timeout_elapsed(), init_weather_anim(), invalidate_main_ui_adaptor(), m, minimap_requires_animation(), Character::posz(), QUIT_WATCH, ui_manager::redraw_invalidated(), input_context::register_action(), input_context::reset_timeout(), SCT, Character::sees(), input_context::set_iso(), input_context::set_timeout(), terrain_requires_animation(), to_translation(), u, map::update_visibility_cache(), uquit, utf8_width(), and scrollingcombattext::vSCT.

Referenced by handle_action().

◆ get_seed()

unsigned int game::get_seed ( ) const

Definition at line 1864 of file game.cpp.

1865{
1866 return seed;
1867}

References seed.

◆ get_user_action_counter()

int game::get_user_action_counter ( ) const

Definition at line 7377 of file game.cpp.

7378{
7379 return user_action_counter;
7380}

References user_action_counter.

◆ get_veh_dir_indicator_location()

cata::optional< tripoint > game::get_veh_dir_indicator_location ( bool  next) const

Returns the location where the indicator should go relative to the reality bubble, or nothing to indicate no indicator should be drawn.

Based on the vehicle the player is driving, if any.

Parameters
nextIf true, bases it on the vehicle the vehicle will turn to next turn, instead of the one it is currently facing.

Definition at line 3641 of file game.cpp.

3642{
3643 if( !get_option<bool>( "VEHICLE_DIR_INDICATOR" ) ) {
3644 return cata::nullopt;
3645 }
3646 const optional_vpart_position vp = m.veh_at( u.pos() );
3647 if( !vp ) {
3648 return cata::nullopt;
3649 }
3650 vehicle *const veh = &vp->vehicle();
3651 rl_vec2d face = next ? veh->dir_vec() : veh->face_vec();
3652 float r = 10.0;
3653 return tripoint( static_cast<int>( r * face.x ), static_cast<int>( r * face.y ), u.pos().z );
3654}
rl_vec2d dir_vec() const

References vehicle::dir_vec(), vehicle::face_vec(), m, cata::nullopt, Character::pos(), u, map::veh_at(), rl_vec2d::x, rl_vec2d::y, and tripoint::z.

Referenced by draw_veh_dir_indicator().

◆ get_world_base_save_path()

std::string game::get_world_base_save_path ( ) const

Base path for saving world data.

This yields a path to a folder.

Definition at line 12544 of file game.cpp.

12545{
12546 if( world_generator->active_world == nullptr ) {
12547 return PATH_INFO::savedir();
12548 }
12549 return world_generator->active_world->folder_path();
12550}
std::string savedir()
Definition: path_info.cpp:250

References PATH_INFO::savedir(), and world_generator.

Referenced by get_player_base_save_path(), load(), load_master(), move_save_to_graveyard(), save(), save_artifacts(), and save_factions_missions_npcs().

◆ get_zoom()

int game::get_zoom ( ) const

Definition at line 7363 of file game.cpp.

7364{
7365#if defined(TILES)
7366 return tileset_zoom;
7367#else
7368 return DEFAULT_TILESET_ZOOM;
7369#endif
7370}

References DEFAULT_TILESET_ZOOM, and tileset_zoom.

Referenced by look_around().

◆ grabbed_furn_move()

bool game::grabbed_furn_move ( const tripoint dp)
private
Strength determines ability to drag furniture

Definition at line 10076 of file game.cpp.

10077{
10078 // Furniture: pull, push, or standing still and nudging object around.
10079 // Can push furniture out of reach.
10080 tripoint fpos = u.pos() + u.grab_point;
10081 // supposed position of grabbed furniture
10082 if( !m.has_furn( fpos ) ) {
10083 // Where did it go? We're grabbing thin air so reset.
10084 add_msg( m_info, _( "No furniture at grabbed point." ) );
10085 u.grab( OBJECT_NONE );
10086 return false;
10087 }
10088
10089 const bool pushing_furniture = dp == u.grab_point;
10090 const bool pulling_furniture = dp == -u.grab_point;
10091 const bool shifting_furniture = !pushing_furniture && !pulling_furniture;
10092
10093 tripoint fdest = fpos + dp; // intended destination of furniture.
10094 // Check floor: floorless tiles don't need to be flat and have no traps
10095 const bool has_floor = m.has_floor( fdest );
10096 // Unfortunately, game::is_empty fails for tiles we're standing on,
10097 // which will forbid pulling, so:
10098 const bool canmove = (
10099 m.passable( fdest ) &&
10100 critter_at<npc>( fdest ) == nullptr &&
10101 critter_at<monster>( fdest ) == nullptr &&
10102 ( !pulling_furniture || is_empty( u.pos() + dp ) ) &&
10103 ( !has_floor || m.has_flag( "FLAT", fdest ) ) &&
10104 !m.has_furn( fdest ) &&
10105 !m.veh_at( fdest ) &&
10106 ( !has_floor || m.tr_at( fdest ).is_null() )
10107 );
10108
10109 const furn_t furntype = m.furn( fpos ).obj();
10110 const int src_items = m.i_at( fpos ).size();
10111 const int dst_items = m.i_at( fdest ).size();
10112
10113 const bool only_liquid_items = std::all_of( m.i_at( fdest ).begin(), m.i_at( fdest ).end(),
10114 [&]( item & liquid_item ) {
10115 return liquid_item.made_of( LIQUID );
10116 } );
10117
10118 const bool dst_item_ok = !m.has_flag( "NOITEM", fdest ) &&
10119 !m.has_flag( "SWIMMABLE", fdest ) &&
10120 !m.has_flag( "DESTROY_ITEM", fdest );
10121
10122 const bool src_item_ok = m.furn( fpos ).obj().has_flag( "CONTAINER" ) ||
10123 m.furn( fpos ).obj().has_flag( "FIRE_CONTAINER" ) ||
10124 m.furn( fpos ).obj().has_flag( "SEALED" );
10125
10126 const int fire_intensity = m.get_field_intensity( fpos, fd_fire );
10127 time_duration fire_age = m.get_field_age( fpos, fd_fire );
10128
10129 int str_req = furntype.move_str_req;
10130 // Factor in weight of items contained in the furniture.
10131 units::mass furniture_contents_weight = 0_gram;
10132 for( auto &contained_item : m.i_at( fpos ) ) {
10133 furniture_contents_weight += contained_item.weight();
10134 }
10135 str_req += furniture_contents_weight / 4_kilogram;
10136 if( !canmove ) {
10137 // TODO: What is something?
10138 add_msg( _( "The %s collides with something." ), furntype.name() );
10139 u.moves -= 50;
10140 return true;
10141 ///\EFFECT_STR determines ability to drag furniture
10142 } else if( str_req > u.get_str() &&
10143 one_in( std::max( 20 - str_req - u.get_str(), 2 ) ) ) {
10144 add_msg( m_bad, _( "You strain yourself trying to move the heavy %s!" ),
10145 furntype.name() );
10146 u.moves -= 100;
10147 u.mod_pain( 1 ); // Hurt ourselves.
10148 return true; // furniture and or obstacle wins.
10149 } else if( !src_item_ok && !only_liquid_items && dst_items > 0 ) {
10150 add_msg( _( "There's stuff in the way." ) );
10151 u.moves -= 50;
10152 return true;
10153 }
10154
10155 u.moves -= str_req * 10;
10156 // Additional penalty if we can't comfortably move it.
10157 if( str_req > u.get_str() ) {
10158 int move_penalty = std::pow( str_req, 2.0 ) + 100.0;
10159 if( move_penalty <= 1000 ) {
10160 if( u.get_str() >= str_req - 3 ) {
10161 u.moves -= std::max( 3000, move_penalty * 10 );
10162 add_msg( m_bad, _( "The %s is really heavy!" ), furntype.name() );
10163 if( one_in( 3 ) ) {
10164 add_msg( m_bad, _( "You fail to move the %s." ), furntype.name() );
10165 return true;
10166 }
10167 } else {
10168 u.moves -= 100;
10169 add_msg( m_bad, _( "The %s is too heavy for you to budge." ), furntype.name() );
10170 return true;
10171 }
10172 }
10173 u.moves -= move_penalty;
10174 if( move_penalty > 500 ) {
10175 add_msg( _( "Moving the heavy %s is taking a lot of time!" ),
10176 furntype.name() );
10177 } else if( move_penalty > 200 ) {
10178 if( one_in( 3 ) ) { // Nag only occasionally.
10179 add_msg( _( "It takes some time to move the heavy %s." ),
10180 furntype.name() );
10181 }
10182 }
10183 }
10185 _( "a scraping noise." ), true, "misc", "scraping" );
10186
10188 ( tripoint_abs_ms( m.getabs( fpos ) ) );
10189
10190 // Actually move the furniture.
10191 m.furn_set( fdest, m.furn( fpos ), atd ? atd->clone() : nullptr );
10192 m.furn_set( fpos, f_null );
10193
10194 if( fire_intensity == 1 && !pulling_furniture ) {
10195 m.remove_field( fpos, fd_fire );
10196 m.set_field_intensity( fdest, fd_fire, fire_intensity );
10197 m.set_field_age( fdest, fd_fire, fire_age );
10198 }
10199
10200 // Is there is only liquids on the ground, remove them after moving furniture.
10201 if( dst_items > 0 && only_liquid_items ) {
10202 m.i_clear( fdest );
10203 }
10204
10205 if( src_items > 0 ) { // Move the stuff inside.
10206 if( dst_item_ok && src_item_ok ) {
10207 // Assume contents of both cells are legal, so we can just swap contents.
10208 std::list<item> temp;
10209 std::move( m.i_at( fpos ).begin(), m.i_at( fpos ).end(),
10210 std::back_inserter( temp ) );
10211 m.i_clear( fpos );
10212 for( auto item_iter = m.i_at( fdest ).begin();
10213 item_iter != m.i_at( fdest ).end(); ++item_iter ) {
10214 m.i_at( fpos ).insert( *item_iter );
10215 }
10216 m.i_clear( fdest );
10217 for( auto &cur_item : temp ) {
10218 m.i_at( fdest ).insert( cur_item );
10219 }
10220 } else {
10221 add_msg( _( "Stuff spills from the %s!" ), furntype.name() );
10222 }
10223 }
10224
10225 if( shifting_furniture ) {
10226 // We didn't move
10227 tripoint d_sum = u.grab_point + dp;
10228 if( std::abs( d_sum.x ) < 2 && std::abs( d_sum.y ) < 2 ) {
10229 u.grab_point = d_sum; // furniture moved relative to us
10230 } else { // we pushed furniture out of reach
10231 add_msg( _( "You let go of the %s." ), furntype.name() );
10232 u.grab( OBJECT_NONE );
10233 }
10234 return true; // We moved furniture but stayed still.
10235 }
10236
10237 if( pushing_furniture && m.impassable( fpos ) ) {
10238 // Not sure how that chair got into a wall, but don't let player follow.
10239 add_msg( _( "You let go of the %1$s as it slides past %2$s." ),
10240 furntype.name(), m.tername( fdest ) );
10241 u.grab( OBJECT_NONE );
10242 return true;
10243 }
10244
10245 return false;
10246}
virtual int get_str() const
Getters for stats exclusive to characters.
Definition: character.cpp:4080
virtual active_tile_data * clone() const =0
void grab(object_type grab_type, const tripoint &grab_point=tripoint_zero)
Definition: avatar.cpp:642
bool is_empty(const tripoint &p)
Returns true if there is no player, NPC, or monster on the tile and move_cost > 0.
Definition: game.cpp:5153
void insert(const item &newitem) override
Definition: map.cpp:153
void remove_field(const tripoint &p, const field_type_id &field_to_remove)
Remove field entry at xy, ignored if the field entry is not present.
Definition: map.cpp:5443
time_duration set_field_age(const tripoint &p, const field_type_id &type, const time_duration &age, bool isoffset=false)
Set age of field entry at point.
Definition: map.cpp:5317
time_duration get_field_age(const tripoint &p, const field_type_id &type) const
Get the age of a field entry (field_entry::age), if there is no field of that type,...
Definition: map.cpp:5351
int get_field_intensity(const tripoint &p, const field_type_id &type) const
Get the intensity of a field entry (field_entry::intensity), if there is no field of that type,...
Definition: map.cpp:5357
int set_field_intensity(const tripoint &p, const field_type_id &type, int new_intensity, bool isoffset=false)
Set intensity of field entry at point, creating if not present, removing if intensity becomes 0.
Definition: map.cpp:5330
std::string tername(const tripoint &p) const
Definition: map.cpp:1704
void i_clear(const tripoint &p)
Definition: map.cpp:4107
void furn_set(const tripoint &p, const furn_id &new_furniture, cata::poly_serialized< active_tile_data > new_active=nullptr)
Sets the furniture at given position.
Definition: map.cpp:1355
bool has_floor(const tripoint &p) const
Definition: map.cpp:2002
tripoint grab_point
Definition: player.h:641
coords::coord_point< tripoint, coords::origin::abs, coords::ms > tripoint_abs_ms
Definition: coordinates.h:486
@ OBJECT_NONE
Definition: enums.h:187
field_type_id fd_fire
Definition: field_type.cpp:345
furn_id f_null
Definition: mapdata.cpp:1095
template active_tile_data * furn_at< active_tile_data >(const tripoint_abs_ms &)
bool move(avatar &you, map &m, const tripoint &d)
void sound(const tripoint &p, int vol, sound_t category, const std::string &description, bool ambient=false, const std::string &id="", const std::string &variant="default")
Sound at (p) of intensity (vol)
Definition: sounds.cpp:177
int move_str_req
Definition: mapdata.h:505
bool has_flag(const std::string &flag) const
Definition: mapdata.h:415

References _, add_msg(), item_stack::begin(), active_tile_data::clone(), item_stack::end(), f_null, fd_fire, map::furn(), active_tiles::furn_at< active_tile_data >(), map::furn_set(), map::get_field_age(), map::get_field_intensity(), Character::get_str(), map::getabs(), avatar::grab(), player::grab_point, map_data_common_t::has_flag(), map::has_flag(), map::has_floor(), map::has_furn(), map::i_at(), map::i_clear(), map::impassable(), map_stack::insert(), is_empty(), trap::is_null(), m, m_bad, m_info, player::mod_pain(), avatar_action::move(), furn_t::move_str_req, sounds::movement, Creature::moves, map_data_common_t::name(), int_id< T >::obj(), OBJECT_NONE, one_in(), map::passable(), Character::pos(), map::remove_field(), map::set_field_age(), map::set_field_intensity(), item_stack::size(), sounds::sound(), map::tername(), map::tr_at(), u, map::veh_at(), tripoint::x, and tripoint::y.

Referenced by grabbed_move().

◆ grabbed_move()

bool game::grabbed_move ( const tripoint dp)
private

Check for dangerous stuff at dest_loc, return false if the player decides not to step there.

Definition at line 10248 of file game.cpp.

10249{
10250 if( u.get_grab_type() == OBJECT_NONE ) {
10251 return false;
10252 }
10253
10254 if( dp.z != 0 ) {
10255 // No dragging stuff up/down stairs yet!
10256 return false;
10257 }
10258
10259 // vehicle: pulling, pushing, or moving around the grabbed object.
10260 if( u.get_grab_type() == OBJECT_VEHICLE ) {
10261 return grabbed_veh_move( dp );
10262 }
10263
10264 if( u.get_grab_type() == OBJECT_FURNITURE ) {
10265 return grabbed_furn_move( dp );
10266 }
10267
10268 add_msg( m_info, _( "Nothing at grabbed point %d,%d,%d or bad grabbed object type." ),
10270 u.grab( OBJECT_NONE );
10271 return false;
10272}
object_type get_grab_type() const
Definition: avatar.cpp:650
bool grabbed_furn_move(const tripoint &dp)
Definition: game.cpp:10076
bool grabbed_veh_move(const tripoint &dp)
Definition: grab.cpp:21
@ OBJECT_FURNITURE
Definition: enums.h:197
@ OBJECT_VEHICLE
Definition: enums.h:193

References _, add_msg(), avatar::get_grab_type(), avatar::grab(), player::grab_point, grabbed_furn_move(), grabbed_veh_move(), m_info, OBJECT_FURNITURE, OBJECT_NONE, OBJECT_VEHICLE, u, tripoint::x, tripoint::y, and tripoint::z.

Referenced by walk_move().

◆ grabbed_veh_move()

bool game::grabbed_veh_move ( const tripoint dp)
private
Strength determines ability to drag vehicles Strength increases speed of dragging vehicles

Definition at line 21 of file grab.cpp.

22{
23 const optional_vpart_position grabbed_vehicle_vp = m.veh_at( u.pos() + u.grab_point );
24 if( !grabbed_vehicle_vp ) {
25 add_msg( m_info, _( "No vehicle at grabbed point." ) );
27 return false;
28 }
29 vehicle *grabbed_vehicle = &grabbed_vehicle_vp->vehicle();
30 if( !grabbed_vehicle ||
31 !grabbed_vehicle->handle_potential_theft( dynamic_cast<player &>( g->u ) ) ) {
32 return false;
33 }
34 const int grabbed_part = grabbed_vehicle_vp->part_index();
35 for( int part_index = 0; part_index < grabbed_vehicle->part_count(); ++part_index ) {
36 monster *mon = grabbed_vehicle->get_pet( part_index );
37 if( mon != nullptr && mon->has_effect( effect_harnessed ) ) {
38 add_msg( m_info, _( "You cannot move this vehicle whilst your %s is harnessed!" ),
39 mon->get_name() );
41 return false;
42 }
43 }
44 const vehicle *veh_under_player = veh_pointer_or_null( m.veh_at( u.pos() ) );
45 if( grabbed_vehicle == veh_under_player ) {
46 u.grab_point = -dp;
47 return false;
48 }
49
50 tripoint dp_veh = -u.grab_point;
51 const tripoint prev_grab = u.grab_point;
52 tripoint next_grab = u.grab_point;
53
54 bool zigzag = false;
55
56 if( dp == prev_grab ) {
57 // We are pushing in the direction of vehicle
58 dp_veh = dp;
59 } else if( std::abs( dp.x + dp_veh.x ) != 2 && std::abs( dp.y + dp_veh.y ) != 2 ) {
60 // Not actually moving the vehicle, don't do the checks
61 u.grab_point = -( dp + dp_veh );
62 return false;
63 } else if( ( dp.x == prev_grab.x || dp.y == prev_grab.y ) &&
64 next_grab.x != 0 && next_grab.y != 0 ) {
65 // Zig-zag (or semi-zig-zag) pull: player is diagonal to vehicle
66 // and moves away from it, but not directly away
67 dp_veh.x = dp.x == -dp_veh.x ? 0 : dp_veh.x;
68 dp_veh.y = dp.y == -dp_veh.y ? 0 : dp_veh.y;
69
70 next_grab = -dp_veh;
71 zigzag = true;
72 } else {
73 // We are pulling the vehicle
74 next_grab = -dp;
75 }
76
77 // Make sure the mass and pivot point are correct
78 grabbed_vehicle->invalidate_mass();
79
80 //vehicle movement: strength check
81 int mc = 0;
82 int str_req = grabbed_vehicle->total_mass() / 25_kilogram; //strength required to move vehicle.
83
84 //if vehicle is rollable we modify str_req based on a function of movecost per wheel.
85
86 // Vehicle just too big to grab & move; 41-45 lets folks have a bit of a window
87 // (Roughly 1.1K kg = danger zone; cube vans are about the max)
88 if( str_req > 45 ) {
89 add_msg( m_info, _( "The %s is too bulky for you to move by hand." ),
90 grabbed_vehicle->name );
91 return true; // No shoving around an RV.
92 }
93
94 const auto &wheel_indices = grabbed_vehicle->wheelcache;
95 if( grabbed_vehicle->valid_wheel_config() ) {
96 //determine movecost for terrain touching wheels
97 const tripoint vehpos = grabbed_vehicle->global_pos3();
98 for( int p : wheel_indices ) {
99 const tripoint wheel_pos = vehpos + grabbed_vehicle->part( p ).precalc[0];
100 const int mapcost = m.move_cost( wheel_pos, grabbed_vehicle );
101 mc += str_req / wheel_indices.size() * mapcost;
102 }
103 //set strength check threshold
104 //if vehicle has many or only one wheel (shopping cart), it is as if it had four.
105 if( wheel_indices.size() > 4 || wheel_indices.size() == 1 ) {
106 str_req = mc / 4 + 1;
107 } else {
108 str_req = mc / wheel_indices.size() + 1;
109 }
110 } else {
111 str_req++;
112 //if vehicle has no wheels str_req make a noise.
113 if( str_req <= u.get_str() ) {
114 sounds::sound( grabbed_vehicle->global_pos3(), str_req * 2, sounds::sound_t::movement,
115 _( "a scraping noise." ), true, "misc", "scraping" );
116 }
117 }
118
119 //final strength check and outcomes
120 ///\EFFECT_STR determines ability to drag vehicles
121 if( str_req <= u.get_str() ) {
122 //calculate exertion factor and movement penalty
123 ///\EFFECT_STR increases speed of dragging vehicles
124 u.moves -= 100 * str_req / std::max( 1, u.get_str() );
125 const int ex = dice( 1, 3 ) - 1 + str_req;
126 if( ex > u.get_str() + 1 ) {
127 // Pain and movement penalty if exertion exceeds character strength
128 add_msg( m_bad, _( "You strain yourself to move the %s!" ), grabbed_vehicle->name );
129 u.moves -= 200;
130 u.mod_pain( 1 );
131 } else if( ex >= u.get_str() ) {
132 // Movement is slow if exertion nearly equals character strength
133 add_msg( _( "It takes some time to move the %s." ), grabbed_vehicle->name );
134 u.moves -= 200;
135 }
136 } else {
137 u.moves -= 100;
138 add_msg( m_bad, _( "You lack the strength to move the %s" ), grabbed_vehicle->name );
139 return true;
140 }
141
142 std::string blocker_name = _( "errors in movement code" );
143 const auto get_move_dir = [&]( const tripoint & dir, const tripoint & from ) {
144 tileray mdir;
145
146 mdir.init( dir.xy() );
147 grabbed_vehicle->turn( mdir.dir() - grabbed_vehicle->face.dir() );
148 grabbed_vehicle->face = grabbed_vehicle->turn_dir;
149 grabbed_vehicle->precalc_mounts( 1, mdir.dir(), grabbed_vehicle->pivot_point() );
150 grabbed_vehicle->adjust_zlevel( 1, dp );
151
152 // Grabbed part has to stay at distance 1 to the player
153 // and in roughly the same direction.
154 const tripoint new_part_pos = grabbed_vehicle->global_pos3() +
155 grabbed_vehicle->part( grabbed_part ).precalc[ 1 ];
156 const tripoint expected_pos = u.pos() + dp + from;
157 const tripoint actual_dir = expected_pos - new_part_pos;
158
159 // Set player location to illegal value so it can't collide with vehicle.
160 const tripoint player_prev = u.pos();
162 std::vector<veh_collision> colls;
163 const bool failed = grabbed_vehicle->collision( colls, actual_dir, true );
164 u.setpos( player_prev );
165 if( !colls.empty() ) {
166 blocker_name = colls.front().target_name;
167 }
168 return failed ? tripoint_zero : actual_dir;
169 };
170
171 // First try the move as intended
172 // But if that fails and the move is a zig-zag, try to recover:
173 // Try to place the vehicle in the position player just left rather than "flattening" the zig-zag
174 tripoint final_dp_veh = get_move_dir( dp_veh, next_grab );
175 if( final_dp_veh == tripoint_zero && zigzag ) {
176 final_dp_veh = get_move_dir( -prev_grab, -dp );
177 next_grab = -dp;
178 }
179
180 if( final_dp_veh == tripoint_zero ) {
181 add_msg( _( "The %s collides with %s." ), grabbed_vehicle->name, blocker_name );
182 u.grab_point = prev_grab;
183 return true;
184 }
185
186 u.grab_point = next_grab;
187
188 m.displace_vehicle( *grabbed_vehicle, final_dp_veh );
189
190 if( grabbed_vehicle ) {
191 grabbed_vehicle->shift_zlevel();
192 grabbed_vehicle->check_falling_or_floating();
193 } else {
194 debugmsg( "Grabbed vehicle disappeared" );
195 return false;
196 }
197
198 for( int p : wheel_indices ) {
199 if( one_in( 2 ) ) {
200 tripoint wheel_p = grabbed_vehicle->global_part_pos3( grabbed_part );
201 grabbed_vehicle->handle_trap( wheel_p, p );
202 }
203 }
204
205 return false;
206
207}
bool displace_vehicle(vehicle &veh, const tripoint &dp)
Definition: map.cpp:1114
int move_cost(const tripoint &p, const vehicle *ignored_vehicle=nullptr) const
Calculate the cost to move past the tile at p.
Definition: map.cpp:1775
units::angle dir() const
Definition: tileray.cpp:74
void init(const point &ad)
Definition: tileray.cpp:27
void turn(units::angle deg)
const point & pivot_point() const
Definition: vehicle.cpp:5649
void adjust_zlevel(int idir=0, const tripoint &offset=tripoint_zero)
tripoint global_pos3() const
Definition: vehicle.cpp:3104
void precalc_mounts(int idir, units::angle dir, const point &pivot)
Definition: vehicle.cpp:3026
bool valid_wheel_config() const
Definition: vehicle.cpp:4282
units::mass total_mass() const
Definition: vehicle.cpp:3129
std::vector< int > wheelcache
Definition: vehicle.h:1798
void check_falling_or_floating()
tileray face
Definition: vehicle.h:1928
void invalidate_mass()
Mark mass caches and pivot cache as dirty.
Definition: vehicle.cpp:6791
int part_count() const
Definition: vehicle.cpp:6898
bool collision(std::vector< veh_collision > &colls, const tripoint &dp, bool just_detect, bool bash_floor=false)
monster * get_pet(int p) const
Definition: vehicle.cpp:3085
vehicle_part & part(int part_num)
Definition: vehicle.cpp:6903
void handle_trap(const tripoint &p, int part)
tripoint global_part_pos3(const int &index) const
Get the coordinates of the studied part of the vehicle.
Definition: vehicle.cpp:3109
void shift_zlevel()
units::angle turn_dir
Definition: vehicle.h:1907
static const efftype_id effect_harnessed("harnessed")
static constexpr tripoint tripoint_zero
Definition: point.h:273
int dice(int number, int sides)
Definition: rng.cpp:85
std::array< tripoint, 2 > precalc
mount translated to face.dir [0] and turn_dir [1]
Definition: vehicle.h:371

References _, add_msg(), vehicle::adjust_zlevel(), vehicle::check_falling_or_floating(), vehicle::collision(), debugmsg, dice(), tileray::dir(), map::displace_vehicle(), effect_harnessed, vehicle::face, failed, g, monster::get_name(), vehicle::get_pet(), Character::get_str(), vehicle::global_part_pos3(), vehicle::global_pos3(), avatar::grab(), player::grab_point, vehicle::handle_potential_theft(), vehicle::handle_trap(), Creature::has_effect(), tileray::init(), vehicle::invalidate_mass(), m, m_bad, m_info, player::mod_pain(), map::move_cost(), sounds::movement, Creature::moves, vehicle::name, OBJECT_NONE, one_in(), vehicle::part(), vehicle::part_count(), vehicle::pivot_point(), Character::pos(), vehicle_part::precalc, vehicle::precalc_mounts(), Character::setpos(), vehicle::shift_zlevel(), sounds::sound(), vehicle::total_mass(), tripoint_zero, vehicle::turn(), vehicle::turn_dir, u, vehicle::valid_wheel_config(), map::veh_at(), veh_pointer_or_null(), vehicle::wheelcache, tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by grabbed_move().

◆ handle_action()

bool game::handle_action ( )
private

Definition at line 1513 of file handle_action.cpp.

1514{
1515 std::string action;
1516 input_context ctxt;
1518 user_turn current_turn;
1519 // Check if we have an auto-move destination
1520 if( u.has_destination() ) {
1522 if( act == ACTION_NULL ) {
1523 add_msg( m_info, _( "Auto-move canceled" ) );
1525 return false;
1526 }
1527 } else if( u.has_destination_activity() ) {
1528 // starts destination activity after the player successfully reached his destination
1530 return false;
1531 } else {
1532 // No auto-move, ask player for input
1533 ctxt = get_player_input( action );
1534 }
1535
1536 const optional_vpart_position vp = m.veh_at( u.pos() );
1537 bool veh_ctrl = !u.is_dead_state() &&
1538 ( ( vp && vp->vehicle().player_in_control( u ) ) || remoteveh() != nullptr );
1539
1540 // If performing an action with right mouse button, co-ordinates
1541 // of location clicked.
1542 cata::optional<tripoint> mouse_target;
1543
1544 if( uquit == QUIT_WATCH && action == "QUIT" ) {
1545 uquit = QUIT_DIED;
1546 return false;
1547 }
1548
1549 if( act == ACTION_NULL ) {
1551
1552 if( act == ACTION_KEYBINDINGS ) {
1553 // already handled by input context
1554 return false;
1555 }
1556
1557 if( act == ACTION_MAIN_MENU ) {
1558 if( uquit == QUIT_WATCH ) {
1559 return false;
1560 }
1561 // No auto-move actions have or can be set at this point.
1563 destination_preview.clear();
1565 if( act == ACTION_NULL ) {
1566 return false;
1567 }
1568 }
1569
1570 if( act == ACTION_ACTIONMENU ) {
1571 if( uquit == QUIT_WATCH ) {
1572 return false;
1573 }
1574 // No auto-move actions have or can be set at this point.
1576 destination_preview.clear();
1578 if( act == ACTION_NULL ) {
1579 return false;
1580 }
1581#if defined(__ANDROID__)
1582 if( get_option<bool>( "ANDROID_ACTIONMENU_AUTOADD" ) && ctxt.get_category() == "DEFAULTMODE" ) {
1583 add_best_key_for_action_to_quick_shortcuts( act, ctxt.get_category(), false );
1584 }
1585#endif
1586 }
1587
1588 if( act == ACTION_KEYBINDINGS ) {
1590 destination_preview.clear();
1591 act = ctxt.display_menu( true );
1592 if( act == ACTION_NULL ) {
1593 return false;
1594 }
1595 }
1596
1599 }
1600
1601 if( act == ACTION_SELECT || act == ACTION_SEC_SELECT ) {
1602 // Mouse button click
1603 if( veh_ctrl ) {
1604 // No mouse use in vehicle
1605 return false;
1606 }
1607
1608 if( u.is_dead_state() ) {
1609 // do not allow mouse actions while dead
1610 return false;
1611 }
1612
1613 const cata::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
1614 if( !mouse_pos ) {
1615 return false;
1616 } else if( !u.sees( *mouse_pos ) ) {
1617 // Not clicked in visible terrain
1618 return false;
1619 }
1620 mouse_target = mouse_pos;
1621
1622 if( act == ACTION_SELECT ) {
1623 // Note: The following has the potential side effect of
1624 // setting auto-move destination state in addition to setting
1625 // act.
1626 if( !try_get_left_click_action( act, *mouse_target ) ) {
1627 return false;
1628 }
1629 } else if( act == ACTION_SEC_SELECT ) {
1630 if( !try_get_right_click_action( act, *mouse_target ) ) {
1631 return false;
1632 }
1633 }
1634 } else if( act != ACTION_TIMEOUT ) {
1635 // act has not been set for an auto-move, so clearing possible
1636 // auto-move destinations. Since initializing an auto-move with
1637 // the mouse may span across multiple actions, we do not clear the
1638 // auto-move destination if the action is only a timeout, as this
1639 // would require the user to double click quicker than the
1640 // timeout delay.
1642 destination_preview.clear();
1643 }
1644 }
1645
1646 if( act == ACTION_NULL ) {
1647 const input_event &&evt = ctxt.get_raw_input();
1648 if( !evt.sequence.empty() ) {
1649 const int ch = evt.get_first_input();
1650 const std::string &&name = inp_mngr.get_keyname( ch, evt.type, true );
1651 if( !get_option<bool>( "NO_UNKNOWN_COMMAND_MSG" ) ) {
1652 add_msg( m_info, _( "Unknown command: \"%s\" (%ld)" ), name, ch );
1653 if( const cata::optional<std::string> hint =
1655 add_msg( m_info, _( "%s at any time to see and edit keybindings relevant to "
1656 "the current context." ),
1657 *hint );
1658 }
1659 }
1660 }
1661 return false;
1662 }
1663
1664 // This has no action unless we're in a special game mode.
1665 gamemode->pre_action( act );
1666
1667 int soffset = get_option<int>( "MOVE_VIEW_OFFSET" );
1668
1669 int before_action_moves = u.moves;
1670
1671 // These actions are allowed while deathcam is active. Registered in game::get_player_input
1672 if( uquit == QUIT_WATCH || !u.is_dead_state() ) {
1673 switch( act ) {
1676 break;
1677
1678 case ACTION_CENTER:
1681 break;
1682
1683 case ACTION_SHIFT_N:
1684 case ACTION_SHIFT_NE:
1685 case ACTION_SHIFT_E:
1686 case ACTION_SHIFT_SE:
1687 case ACTION_SHIFT_S:
1688 case ACTION_SHIFT_SW:
1689 case ACTION_SHIFT_W:
1690 case ACTION_SHIFT_NW: {
1691 static const std::map<action_id, std::pair<point, point>> shift_delta = {
1700 };
1702 shift_delta.at( act ).second * soffset : shift_delta.at( act ).first * soffset;
1703 }
1704 break;
1705
1706 case ACTION_LOOK:
1707 look_around();
1708 break;
1709
1710 case ACTION_KEYBINDINGS:
1711 // already handled by input context
1712 break;
1713
1714 default:
1715 break;
1716 }
1717 }
1718
1719 // actions allowed only while alive
1720 if( !u.is_dead_state() ) {
1721 switch( act ) {
1722 case ACTION_NULL:
1723 case NUM_ACTIONS:
1724 break; // dummy entries
1725 case ACTION_ACTIONMENU:
1726 case ACTION_MAIN_MENU:
1727 case ACTION_KEYBINDINGS:
1728 break; // handled above
1729
1730 case ACTION_TIMEOUT:
1731 if( check_safe_mode_allowed( false ) ) {
1732 u.pause();
1733 }
1734 break;
1735
1736 case ACTION_PAUSE:
1737 if( check_safe_mode_allowed() ) {
1738 u.pause();
1739 }
1740 break;
1741
1742 case ACTION_CYCLE_MOVE:
1744 break;
1745
1746 case ACTION_RESET_MOVE:
1748 break;
1749
1750 case ACTION_TOGGLE_RUN:
1752 break;
1753
1756 break;
1757
1760 break;
1761
1762 case ACTION_MOVE_FORTH:
1764 case ACTION_MOVE_RIGHT:
1766 case ACTION_MOVE_BACK:
1768 case ACTION_MOVE_LEFT:
1770 if( !u.get_value( "remote_controlling" ).empty() &&
1774 } else if( veh_ctrl ) {
1775 // vehicle control uses x for steering and y for ac/deceleration,
1776 // so no rotation needed
1778 } else {
1780 if( auto_travel_mode && !u.is_auto_moving() ) {
1781 for( int i = 0; i < SEEX; i++ ) {
1782 tripoint auto_travel_destination( u.posx() + dest_delta.x * ( SEEX - i ),
1783 u.posy() + dest_delta.y * ( SEEX - i ),
1784 u.posz() );
1786 auto_travel_destination,
1788 u.get_path_avoid() );
1789 if( !destination_preview.empty() ) {
1792 break;
1793 }
1794 }
1797 if( dest_next == point_zero ) {
1799 }
1800 dest_delta = dest_next;
1801 }
1802 if( !avatar_action::move( u, m, dest_delta ) ) {
1803 // auto-move should be canceled due to a failed move or obstacle
1805 }
1806 }
1807 break;
1808 case ACTION_MOVE_DOWN:
1809 if( u.is_mounted() ) {
1810 auto mon = u.mounted_creature.get();
1811 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1812 add_msg( m_info, _( "You can't go down stairs while you're riding." ) );
1813 break;
1814 }
1815 }
1816 if( !u.in_vehicle ) {
1817 vertical_move( -1, false );
1818 } else if( veh_ctrl && vp->vehicle().is_rotorcraft() ) {
1820 }
1821 break;
1822
1823 case ACTION_MOVE_UP:
1824 if( u.is_mounted() ) {
1825 auto mon = u.mounted_creature.get();
1826 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1827 add_msg( m_info, _( "You can't go down stairs while you're riding." ) );
1828 break;
1829 }
1830 }
1831 if( !u.in_vehicle ) {
1832 vertical_move( 1, false );
1833 } else if( veh_ctrl && vp->vehicle().is_rotorcraft() ) {
1835 } else if( veh_ctrl && vp->vehicle().has_part( "ROTOR" ) &&
1836 !vp->vehicle().has_sufficient_rotorlift() ) {
1837 add_msg( m_bad, _( "The rotors struggle to generate enough lift!" ) );
1838 }
1839 break;
1840
1841 case ACTION_OPEN:
1843 add_msg( m_info, _( "You can't open things while you're in your shell." ) );
1844 } else if( u.is_mounted() ) {
1845 add_msg( m_info, _( "You can't open things while you're riding." ) );
1846 } else {
1847 open();
1848 }
1849 break;
1850
1851 case ACTION_CLOSE:
1853 add_msg( m_info, _( "You can't close things while you're in your shell." ) );
1854 } else if( u.is_mounted() ) {
1855 auto mon = u.mounted_creature.get();
1856 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1857 add_msg( m_info, _( "You can't close things while you're riding." ) );
1858 }
1859 } else if( mouse_target ) {
1860 doors::close_door( m, u, *mouse_target );
1861 } else {
1862 close();
1863 }
1864 break;
1865
1866 case ACTION_SMASH:
1867 if( veh_ctrl ) {
1868 handbrake();
1869 } else if( u.has_active_mutation( trait_SHELL2 ) ) {
1870 add_msg( m_info, _( "You can't smash things while you're in your shell." ) );
1871 } else {
1872 smash();
1873 }
1874 break;
1875
1876 case ACTION_EXAMINE:
1878 add_msg( m_info, _( "You can't examine your surroundings while you're in your shell." ) );
1879 } else if( mouse_target ) {
1880 examine( *mouse_target );
1881 } else {
1882 examine();
1883 }
1884 break;
1885
1886 case ACTION_ADVANCEDINV:
1888 add_msg( m_info, _( "You can't move mass quantities while you're in your shell." ) );
1889 } else if( u.is_mounted() ) {
1890 add_msg( m_info, _( "You can't move mass quantities while you're riding." ) );
1891 } else {
1893 }
1894 break;
1895
1896 case ACTION_PICKUP:
1898 add_msg( m_info, _( "You can't pick anything up while you're in your shell." ) );
1899 } else if( u.is_mounted() ) {
1900 add_msg( m_info, _( "You can't pick anything up while you're riding." ) );
1901 } else if( mouse_target ) {
1902 pickup( *mouse_target );
1903 } else {
1904 pickup();
1905 }
1906 break;
1907
1908 case ACTION_PICKUP_FEET:
1910 add_msg( m_info, _( "You can't pick anything up while you're in your shell." ) );
1911 } else {
1912 pickup_feet();
1913 }
1914 break;
1915
1916 case ACTION_GRAB:
1918 add_msg( m_info, _( "You can't grab things while you're in your shell." ) );
1919 } else if( u.is_mounted() ) {
1920 add_msg( m_info, _( "You can't grab things while you're riding." ) );
1921 } else {
1922 grab();
1923 }
1924 break;
1925
1926 case ACTION_HAUL:
1928 add_msg( m_info, _( "You can't haul things while you're in your shell." ) );
1929 } else if( u.is_mounted() ) {
1930 add_msg( m_info, _( "You can't haul things while you're riding." ) );
1931 } else {
1932 haul();
1933 }
1934 break;
1935
1936 case ACTION_BUTCHER:
1938 add_msg( m_info, _( "You can't butcher while you're in your shell." ) );
1939 } else if( u.is_mounted() ) {
1940 add_msg( m_info, _( "You can't butcher while you're riding." ) );
1941 } else {
1942 butcher();
1943 }
1944 break;
1945
1946 case ACTION_CHAT:
1947 chat();
1948 break;
1949
1950 case ACTION_PEEK:
1952 add_msg( m_info, _( "You can't peek around corners while you're in your shell." ) );
1953 } else if( u.is_mounted() ) {
1954 add_msg( m_info, _( "You can't peek around corners while you're riding." ) );
1955 } else {
1956 peek();
1957 }
1958 break;
1959
1960 case ACTION_LIST_ITEMS:
1962 break;
1963
1964 case ACTION_ZONES:
1965 zones_manager();
1966 break;
1967
1968 case ACTION_LOOT:
1969 loot();
1970 break;
1971
1972 case ACTION_INVENTORY:
1974 break;
1975
1976 case ACTION_COMPARE:
1978 break;
1979
1980 case ACTION_ORGANIZE:
1982 break;
1983
1984 case ACTION_USE:
1985 // Shell-users are presumed to be able to mess with their inventories, etc
1986 // while in the shell. Eating, gear-changing, and item use are OK.
1988 break;
1989
1990 case ACTION_USE_WIELDED:
1991 u.use_wielded();
1992 break;
1993
1994 case ACTION_WEAR:
1995 wear();
1996 break;
1997
1998 case ACTION_TAKE_OFF:
1999 takeoff();
2000 break;
2001
2002 case ACTION_EAT:
2003 if( !avatar_action::eat_here( u ) ) {
2005 }
2006 break;
2007
2009 if( !avatar_action::eat_here( u ) ) {
2011 }
2012 break;
2013
2014 case ACTION_READ:
2015 // Shell-users are presumed to have the book just at an opening and read it that way
2016 read();
2017 break;
2018
2019 case ACTION_WIELD:
2020 wield();
2021 break;
2022
2023 case ACTION_PICK_STYLE:
2024 u.martial_arts_data->pick_style( u );
2025 break;
2026
2027 case ACTION_RELOAD_ITEM:
2028 reload_item();
2029 break;
2030
2032 reload_weapon();
2033 break;
2034
2037 break;
2038
2039 case ACTION_UNLOAD:
2041 break;
2042
2043 case ACTION_MEND:
2045 break;
2046
2047 case ACTION_THROW: {
2048 item_location loc;
2049 avatar_action::plthrow( g->u, loc );
2050 break;
2051 }
2052
2053 case ACTION_FIRE:
2054 fire();
2055 break;
2056
2057 case ACTION_CAST_SPELL:
2058 cast_spell();
2059 break;
2060
2061 case ACTION_FIRE_BURST: {
2062 if( u.weapon.gun_set_mode( gun_mode_id( "AUTO" ) ) ) {
2064 }
2065 break;
2066 }
2067
2069 if( u.is_armed() && u.weapon.is_gun() && !u.weapon.is_gunmod() ) {
2070 if( u.weapon.gun_all_modes().size() > 1 ) {
2072 } else {
2073 add_msg( m_info, _( "Your %s has only one firing mode." ), u.weapon.display_name() );
2074 }
2075 }
2076 break;
2077
2079 if( u.is_armed() && u.weapon.is_gun() && !u.weapon.is_gunmod() ) {
2081 }
2082 break;
2083
2084 case ACTION_DROP:
2085 // You CAN drop things to your own tile while in the shell.
2086 drop();
2087 break;
2088
2089 case ACTION_DIR_DROP:
2091 add_msg( m_info, _( "You can't drop things to another tile while you're in your shell." ) );
2092 } else {
2094 }
2095 break;
2096 case ACTION_BIONICS:
2097 u.power_bionics();
2098 break;
2099 case ACTION_MUTATIONS:
2101 break;
2102
2103 case ACTION_SORT_ARMOR:
2104 u.sort_armor();
2105 break;
2106
2107 case ACTION_WAIT:
2108 wait();
2109 break;
2110
2111 case ACTION_CRAFT:
2113 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2114 } else if( u.is_mounted() ) {
2115 add_msg( m_info, _( "You can't craft while you're riding." ) );
2116 } else {
2117 u.craft();
2118 }
2119 break;
2120
2121 case ACTION_RECRAFT:
2123 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2124 } else if( u.is_mounted() ) {
2125 add_msg( m_info, _( "You can't craft while you're riding." ) );
2126 } else {
2127 u.recraft();
2128 }
2129 break;
2130
2131 case ACTION_LONGCRAFT:
2133 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2134 } else if( u.is_mounted() ) {
2135 add_msg( m_info, _( "You can't craft while you're riding." ) );
2136 } else {
2137 u.long_craft();
2138 }
2139 break;
2140
2141 case ACTION_DISASSEMBLE:
2142 if( u.controlling_vehicle ) {
2143 add_msg( m_info, _( "You can't disassemble items while driving." ) );
2144 } else if( u.is_mounted() ) {
2145 add_msg( m_info, _( "You can't disassemble items while you're riding." ) );
2146 } else {
2147 u.disassemble();
2148 }
2149 break;
2150
2151 case ACTION_CONSTRUCT:
2152 if( u.in_vehicle ) {
2153 add_msg( m_info, _( "You can't construct while in a vehicle." ) );
2154 } else if( u.has_active_mutation( trait_SHELL2 ) ) {
2155 add_msg( m_info, _( "You can't construct while you're in your shell." ) );
2156 } else if( u.is_mounted() ) {
2157 add_msg( m_info, _( "You can't construct while you're riding." ) );
2158 } else {
2159 construction_menu( false );
2160 }
2161 break;
2162
2163 case ACTION_SLEEP:
2164 if( veh_ctrl ) {
2165 add_msg( m_info, _( "Vehicle control has moved, %s" ),
2166 press_x( ACTION_CONTROL_VEHICLE, _( "new binding is " ),
2167 _( "new default binding is '^'." ) ) );
2168 } else {
2169 sleep();
2170 }
2171 break;
2172
2175 add_msg( m_info, _( "You can't operate a vehicle while you're in your shell." ) );
2176 } else if( u.is_mounted() ) {
2177 u.dismount();
2178 } else {
2180 }
2181 break;
2182
2185 add_msg( m_info, auto_travel_mode ? _( "Auto travel mode ON!" ) : _( "Auto travel mode OFF!" ) );
2186 break;
2187
2189 if( safe_mode == SAFE_MODE_OFF ) {
2191 mostseen = 0;
2192 add_msg( m_info, _( "Safe mode ON!" ) );
2193 } else {
2196 add_msg( m_info, get_option<bool>( "AUTOSAFEMODE" )
2197 ? _( "Safe mode OFF! (Auto safe mode still enabled!)" ) : _( "Safe mode OFF!" ) );
2198 }
2202 }
2203 break;
2204
2206 auto &autosafemode_option = get_options().get_option( "AUTOSAFEMODE" );
2207 add_msg( m_info, autosafemode_option.value_as<bool>()
2208 ? _( "Auto safe mode OFF!" ) : _( "Auto safe mode ON!" ) );
2209 autosafemode_option.setNext();
2210 break;
2211 }
2212
2214 if( safe_mode == SAFE_MODE_STOP ) {
2215 add_msg( m_info, _( "Ignoring enemy!" ) );
2216 for( auto &elem : u.get_mon_visible().new_seen_mon ) {
2217 monster &critter = *elem;
2218 critter.ignoring = rl_dist( u.pos(), critter.pos() );
2219 }
2221 } else if( u.has_effect( effect_laserlocked ) ) {
2222 if( u.has_trait( trait_PROF_CHURL ) ) {
2223 add_msg( m_warning, _( "You make the sign of the cross." ) );
2224 } else {
2225 add_msg( m_info, _( "Ignoring laser targeting!" ) );
2226 }
2229 }
2230 break;
2231
2233 if( safe_mode == SAFE_MODE_STOP && !get_safemode().empty() ) {
2235 add_msg( m_info, _( "Creature whitelisted: %s" ), get_safemode().lastmon_whitelist );
2237 mostseen = 0;
2238 } else {
2239 get_safemode().show();
2240 }
2241 break;
2242
2243 case ACTION_SUICIDE:
2244 if( query_yn( _( "Commit suicide?" ) ) ) {
2245 if( query_yn( _( "REALLY commit suicide?" ) ) ) {
2246 u.moves = 0;
2247 u.place_corpse();
2249 }
2250 }
2251 break;
2252
2253 case ACTION_SAVE:
2254 if( query_yn( _( "Save and quit?" ) ) ) {
2255 if( save() ) {
2256 u.moves = 0;
2257 uquit = QUIT_SAVED;
2258 }
2259 }
2260 break;
2261
2262 case ACTION_QUICKSAVE:
2263 quicksave();
2264 return false;
2265
2266 case ACTION_QUICKLOAD:
2267 quickload();
2268 return false;
2269
2270 case ACTION_PL_INFO:
2272 break;
2273
2274 case ACTION_MAP:
2276 break;
2277
2278 case ACTION_SKY:
2279 if( m.is_outside( u.pos() ) ) {
2281 } else {
2282 add_msg( m_info, _( "You can't see the sky from here." ) );
2283 }
2284 break;
2285
2286 case ACTION_MISSIONS:
2287 list_missions();
2288 break;
2289
2290 case ACTION_SCORES:
2292 break;
2293
2294 case ACTION_FACTIONS:
2295 faction_manager_ptr->display();
2296 break;
2297
2298 case ACTION_MORALE:
2299 u.disp_morale();
2300 break;
2301
2302 case ACTION_MESSAGES:
2304 break;
2305
2306 case ACTION_HELP:
2308 break;
2309
2310 case ACTION_OPTIONS:
2311 get_options().show( true );
2312 break;
2313
2314 case ACTION_AUTOPICKUP:
2316 break;
2317
2318 case ACTION_AUTONOTES:
2320 break;
2321
2322 case ACTION_SAFEMODE:
2323 get_safemode().show();
2324 break;
2325
2326 case ACTION_COLOR:
2327 all_colors.show_gui();
2328 break;
2329
2330 case ACTION_WORLD_MODS:
2331 world_generator->show_active_world_mods( world_generator->active_world->active_mod_order );
2332 break;
2333
2334 case ACTION_DEBUG:
2336 break; //don't do anything when sharing and not debugger
2337 }
2339 break;
2340
2343 break;
2344
2347 break;
2348
2351 break;
2352
2355 break;
2356
2358 get_options().get_option( "AUTO_FEATURES" ).setNext();
2359 get_options().save();
2360 //~ Auto Features are now ON/OFF
2361 add_msg( _( "%s are now %s." ),
2362 get_options().get_option( "AUTO_FEATURES" ).getMenuText(),
2363 get_option<bool>( "AUTO_FEATURES" ) ? _( "ON" ) : _( "OFF" ) );
2364 break;
2365
2367 get_options().get_option( "AUTO_PULP_BUTCHER" ).setNext();
2368 get_options().save();
2369 //~ Auto Pulp/Pulp Adjacent/Butcher is now set to x
2370 add_msg( _( "%s is now set to %s." ),
2371 get_options().get_option( "AUTO_PULP_BUTCHER" ).getMenuText(),
2372 get_options().get_option( "AUTO_PULP_BUTCHER" ).getValueName() );
2373 break;
2374
2376 get_options().get_option( "AUTO_MINING" ).setNext();
2377 get_options().save();
2378 //~ Auto Mining is now ON/OFF
2379 add_msg( _( "%s is now %s." ),
2380 get_options().get_option( "AUTO_MINING" ).getMenuText(),
2381 get_option<bool>( "AUTO_MINING" ) ? _( "ON" ) : _( "OFF" ) );
2382 break;
2383
2385 if( g->u.get_value( "THIEF_MODE" ) == "THIEF_ASK" ) {
2386 u.set_value( "THIEF_MODE", "THIEF_HONEST" );
2387 u.set_value( "THIEF_MODE_KEEP", "YES" );
2388 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2389 add_msg( _( "You will not pick up other peoples belongings." ) );
2390 } else if( g->u.get_value( "THIEF_MODE" ) == "THIEF_HONEST" ) {
2391 u.set_value( "THIEF_MODE", "THIEF_STEAL" );
2392 u.set_value( "THIEF_MODE_KEEP", "YES" );
2393 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2394 add_msg( _( "You will pick up also those things that belong to others!" ) );
2395 } else if( g->u.get_value( "THIEF_MODE" ) == "THIEF_STEAL" ) {
2396 u.set_value( "THIEF_MODE", "THIEF_ASK" );
2397 u.set_value( "THIEF_MODE_KEEP", "NO" );
2398 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2399 add_msg( _( "You will be reminded not to steal." ) );
2400 } else {
2401 // ERROR
2402 add_msg( _( "THIEF_MODE CONTAINED BAD VALUE [ %s ]!" ), g->u.get_value( "THIEF_MODE" ) );
2403 }
2404 break;
2405
2407 get_options().get_option( "AUTO_FORAGING" ).setNext();
2408 get_options().save();
2409 //~ Auto Foraging is now set to x
2410 add_msg( _( "%s is now set to %s." ),
2411 get_options().get_option( "AUTO_FORAGING" ).getMenuText(),
2412 get_options().get_option( "AUTO_FORAGING" ).getValueName() );
2413 break;
2414
2416 get_options().get_option( "AUTO_PICKUP" ).setNext();
2417 get_options().save();
2418 //~ Auto pickup is now set to x
2419 add_msg( _( "%s is now set to %s." ),
2420 get_options().get_option( "AUTO_PICKUP" ).getMenuText(),
2421 get_options().get_option( "AUTO_PICKUP" ).getValueName() );
2422 break;
2423
2426 break; //don't do anything when sharing and not debugger
2427 }
2428 display_scent();
2429 break;
2430
2433 break; //don't do anything when sharing and not debugger
2434 }
2435 display_scent();
2436 break;
2437
2440 break; //don't do anything when sharing and not debugger
2441 }
2443 break;
2446 break; //don't do anything when sharing and not debugger
2447 }
2449 break;
2452 break; //don't do anything when sharing and not debugger
2453 }
2455 break;
2456
2459 break; //don't do anything when sharing and not debugger
2460 }
2462 break;
2463
2466 break; //don't do anything when sharing and not debugger
2467 }
2469 break;
2470
2473 break; //don't do anything when sharing and not debugger
2474 }
2476 break;
2477
2479 g->debug_submap_grid_overlay = !g->debug_submap_grid_overlay;
2480 break;
2481
2484 break;
2485
2488 break; //don't do anything when sharing and not debugger
2489 }
2491 if( debug_mode ) {
2492 add_msg( m_info, _( "Debug mode ON!" ) );
2493 } else {
2494 add_msg( m_info, _( "Debug mode OFF!" ) );
2495 }
2496 break;
2497
2498 case ACTION_ZOOM_IN:
2499 zoom_in();
2501 break;
2502
2503 case ACTION_ZOOM_OUT:
2504 zoom_out();
2506 break;
2507
2508 case ACTION_ITEMACTION:
2510 break;
2511
2512 case ACTION_AUTOATTACK:
2514 break;
2515
2516 default:
2517 break;
2518 }
2519 }
2520 if( act != ACTION_TIMEOUT ) {
2521 u.mod_moves( -current_turn.moves_elapsed() );
2522 }
2523 gamemode->post_action( act );
2524
2525 u.movecounter = ( !u.is_dead_state() ? ( before_action_moves - u.moves ) : 0 );
2526 dbg( DL::Info ) << string_format( "%s: [%d] %d - %d = %d", action_ident( act ),
2527 to_turn<int>( calendar::turn ), before_action_moves, u.movecounter, u.moves );
2528 return ( !u.is_dead_state() );
2529}
cata::optional< std::string > press_x_if_bound(action_id act)
Definition: action.cpp:468
bool can_action_change_worldstate(const action_id act)
Lookup whether an action can affect the state of the game world.
Definition: action.cpp:347
action_id look_up_action(const std::string &ident)
Lookup an action ID by its unique string identifier.
Definition: action.cpp:417
action_id handle_main_menu()
Show in-game main menu.
Definition: action.cpp:935
point get_delta_from_movement_action(const action_id act, const iso_rotate rot)
Definition: action.cpp:506
action_id handle_action_menu()
Show the action menu.
Definition: action.cpp:653
@ ACTION_SAFEMODE
Open safemode manager.
Definition: action.h:265
@ ACTION_PEEK
Peek through something (e.g.
Definition: action.h:121
@ ACTION_OPEN
Open an item (e.g.
Definition: action.h:99
@ ACTION_CRAFT
Open crafting menu.
Definition: action.h:199
@ ACTION_DROP
Open the drop-item menu.
Definition: action.h:181
@ ACTION_READ
Open the read menu.
Definition: action.h:153
@ ACTION_TOGGLE_AUTO_PICKUP
Turn auto pickup on/off.
Definition: action.h:309
@ ACTION_MOVE_BACK_LEFT
Move towards bottom-left of screen / decelerate and steer left.
Definition: action.h:51
@ ACTION_ZOOM_IN
Zoom view out.
Definition: action.h:287
@ ACTION_EAT
Open the default consume item menu.
Definition: action.h:149
@ ACTION_SMASH
Smash something.
Definition: action.h:103
@ ACTION_ADVANCEDINV
Open the advanced inventory screen.
Definition: action.h:135
@ ACTION_QUICKSAVE
Quicksave the game.
Definition: action.h:227
@ ACTION_HELP
Display help screen.
Definition: action.h:253
@ ACTION_MESSAGES
Display messages screen.
Definition: action.h:251
@ ACTION_ZONES
Open the zone manager.
Definition: action.h:125
@ ACTION_TOGGLE_PIXEL_MINIMAP
Turn pixel minimap on/off.
Definition: action.h:293
@ ACTION_USE
Open the use menu.
Definition: action.h:141
@ ACTION_QUICKLOAD
Quickload the game.
Definition: action.h:229
@ ACTION_LIST_ITEMS
List items and monsters in a given square.
Definition: action.h:123
@ ACTION_DEBUG
Open debug menu.
Definition: action.h:277
@ ACTION_OPTIONS
Display options window.
Definition: action.h:259
@ ACTION_MOVE_FORTH
Move towards top of screen / accelerate.
Definition: action.h:41
@ ACTION_PICK_STYLE
Open the martial-arts style menu.
Definition: action.h:157
@ ACTION_CONSTRUCT
Open construct menu.
Definition: action.h:205
@ ACTION_MOVE_FORTH_RIGHT
Move towards top-right of screen / accelerate and steer right.
Definition: action.h:43
@ ACTION_SORT_ARMOR
Open the armor sorting menu.
Definition: action.h:189
@ ACTION_OPEN_CONSUME
Open the custom consume item menu.
Definition: action.h:151
@ ACTION_MORALE
Display morale effects screen.
Definition: action.h:249
@ ACTION_NULL
Invalid action used for various lookup errors.
Definition: action.h:24
@ ACTION_RESET_MOVE
Reset movement mode to walk
Definition: action.h:63
@ ACTION_CHAT
Chat with something.
Definition: action.h:117
@ ACTION_RELOAD_WIELDED
Attempt to reload wielded object.
Definition: action.h:163
@ ACTION_MOVE_DOWN
Descend a staircase.
Definition: action.h:57
@ ACTION_MISSIONS
Display missions screen.
Definition: action.h:243
@ ACTION_AUTONOTES
Open autonotes manager.
Definition: action.h:263
@ ACTION_WIELD
Open the wield menu.
Definition: action.h:155
@ ACTION_THROW
Open the throw menu.
Definition: action.h:169
@ ACTION_TOGGLE_AUTO_MINING
Turn auto mining on/off.
Definition: action.h:305
@ ACTION_INVENTORY
Open the primary inventory screen.
Definition: action.h:133
@ ACTION_TOGGLE_AUTOSAFE
Turn automatic triggering of safemode on/off.
Definition: action.h:217
@ ACTION_OPEN_MOVEMENT
Open movement mode menu.
Definition: action.h:69
@ ACTION_COMPARE
Open the item compare screen.
Definition: action.h:137
@ ACTION_SCORES
Display scores screen.
Definition: action.h:245
@ ACTION_BUTCHER
Butcher or disassemble objects in current square.
Definition: action.h:115
@ ACTION_SEC_SELECT
Click on a point with secondary mouse button (usually right button)
Definition: action.h:31
@ ACTION_TOGGLE_CROUCH
Toggle crouch on/off.
Definition: action.h:67
@ ACTION_TOGGLE_HOUR_TIMER
Toggle timing of the game hours.
Definition: action.h:325
@ ACTION_SELECT
Click on a point with primary mouse button (usually left button)
Definition: action.h:29
@ ACTION_MAIN_MENU
Display main menu.
Definition: action.h:255
@ ACTION_DISPLAY_SUBMAP_GRID
Toggle submap grid overlay.
Definition: action.h:323
@ ACTION_WAIT
Open wait menu.
Definition: action.h:197
@ ACTION_ACTIONMENU
Open the action menu.
Definition: action.h:289
@ ACTION_DISASSEMBLE
Open disassemble menu.
Definition: action.h:207
@ ACTION_LOOT
Sort out the loot.
Definition: action.h:127
@ ACTION_TOGGLE_FULLSCREEN
Toggle full-screen mode.
Definition: action.h:275
@ ACTION_MAP
Display over-map.
Definition: action.h:239
@ ACTION_MEND
Open the mending menu (e.g.
Definition: action.h:167
@ ACTION_TOGGLE_THIEF_MODE
Toggle permanent attitude to stealing.
Definition: action.h:219
@ ACTION_USE_WIELDED
Use currently wielded item.
Definition: action.h:143
@ ACTION_PL_INFO
Display player status screen.
Definition: action.h:237
@ ACTION_DISPLAY_SCENT_TYPE
Toggle scent type map.
Definition: action.h:281
@ ACTION_TOGGLE_AUTO_FORAGING
Turn auto foraging on/off.
Definition: action.h:307
@ ACTION_FIRE_BURST
Burst-fire the current weapon.
Definition: action.h:173
@ ACTION_BIONICS
Open the bionics menu.
Definition: action.h:185
@ ACTION_CONTROL_VEHICLE
Open vehicle control menu.
Definition: action.h:211
@ ACTION_SAVE
Save the game and quit.
Definition: action.h:225
@ ACTION_MOVE_UP
Ascend a staircase.
Definition: action.h:59
@ ACTION_TOGGLE_PANEL_ADM
Turn admin panel on/off.
Definition: action.h:295
@ ACTION_TOGGLE_AUTO_PULP_BUTCHER
Change auto pulp/butcher mode.
Definition: action.h:303
@ ACTION_TOGGLE_AUTO_TRAVEL_MODE
Turn auto travel mode on/off.
Definition: action.h:213
@ ACTION_COLOR
Open color manager.
Definition: action.h:267
@ ACTION_TIMEOUT
Input timeout.
Definition: action.h:39
@ ACTION_TOGGLE_RUN
Toggle run on/off.
Definition: action.h:65
@ ACTION_FACTIONS
Display factions screen.
Definition: action.h:247
@ ACTION_GRAB
Grab or let go of an object.
Definition: action.h:111
@ ACTION_MOVE_BACK
Move towards bottom of screen / decelerate.
Definition: action.h:49
@ ACTION_CAST_SPELL
Cast a spell (only if any spells are known)
Definition: action.h:179
@ ACTION_DIR_DROP
Drop items in a given direction.
Definition: action.h:183
@ ACTION_AUTOATTACK
Auto select and attack hostile creature within range.
Definition: action.h:191
@ ACTION_CYCLE_MOVE
Cycle run/walk/crouch mode.
Definition: action.h:61
@ ACTION_SKY
Show sky state for trying to predict weather.
Definition: action.h:241
@ ACTION_FIRE
Fire the wielded weapon, or open fire menu if none.
Definition: action.h:171
@ ACTION_PAUSE
Pause an on-going activity.
Definition: action.h:37
@ ACTION_MOVE_BACK_RIGHT
Move towards bottom-right of screen / decelerate and steer right.
Definition: action.h:47
@ ACTION_MUTATIONS
Open the mutations menu.
Definition: action.h:187
@ ACTION_HAUL
Haul pile of items, or let go of them.
Definition: action.h:113
@ ACTION_MOVE_RIGHT
Move / steer right.
Definition: action.h:45
@ ACTION_SLEEP
Open sleep menu.
Definition: action.h:209
@ ACTION_ITEMACTION
Open the item uses menu.
Definition: action.h:291
@ ACTION_MOVE_LEFT
Move / steer left.
Definition: action.h:53
@ ACTION_SELECT_DEFAULT_AMMO
Change default ammo for current weapon.
Definition: action.h:177
@ ACTION_AUTOPICKUP
Open autopickup manager.
Definition: action.h:261
@ ACTION_SUICIDE
Commit suicide.
Definition: action.h:231
@ NUM_ACTIONS
Not an action, serves as count of enumerated actions.
Definition: action.h:327
@ ACTION_ZOOM_OUT
Zoom view in.
Definition: action.h:285
@ ACTION_SELECT_FIRE_MODE
Change fire mode of the current weapon.
Definition: action.h:175
@ ACTION_UNLOAD
Open the unload item (e.g.
Definition: action.h:165
@ ACTION_RECRAFT
Repeat last craft command.
Definition: action.h:201
@ ACTION_TAKE_OFF
Open the take-off clothing selection menu.
Definition: action.h:147
@ ACTION_PICKUP_FEET
Pick up items from current square.
Definition: action.h:109
@ ACTION_TOGGLE_AUTO_FEATURES
Turn auto features on/off.
Definition: action.h:301
@ ACTION_WORLD_MODS
Open active world mods.
Definition: action.h:269
@ ACTION_TOGGLE_DEBUG_MODE
Toggle debug mode.
Definition: action.h:283
@ ACTION_ORGANIZE
Swap inventory letters.
Definition: action.h:139
@ ACTION_MOVE_FORTH_LEFT
Move towards top-left of screen / accelerate and steer left.
Definition: action.h:55
@ ACTION_RELOAD_TILESET
Reload current tileset.
Definition: action.h:299
@ ACTION_CLOSE
Close an item (e.g.
Definition: action.h:101
@ ACTION_RELOAD_WEAPON
Attempt to reload wielded weapon, then fall back to the load item select menu.
Definition: action.h:161
@ ACTION_RELOAD_ITEM
Open the load item (e.g.
Definition: action.h:159
@ ACTION_PICKUP
Pick up items from current/adjacent squares.
Definition: action.h:107
@ ACTION_LONGCRAFT
Open batch crafting menu.
Definition: action.h:203
@ ACTION_WEAR
Open the wear clothing selection menu.
Definition: action.h:145
void create_advanced_inv()
auto_notes::auto_note_settings & get_auto_notes_settings()
Definition: auto_note.cpp:386
auto_pickup::player_settings & get_auto_pickup()
Definition: auto_pickup.cpp:38
bool tile_iso
Using isometric tileset.
bool debug_mode
Extended debugging mode, can be toggled during game.
bool has_active_mutation(const trait_id &b) const
Definition: mutation.cpp:367
pimpl< character_martial_arts > martial_arts_data
Definition: character.h:1533
bool has_active_item(const itype_id &id) const
Whether the player carries an active item of the given item type.
Definition: character.cpp:2564
void place_corpse()
std::set< tripoint > get_path_avoid() const override
Returns a set of points we do not want to path through.
Definition: character.cpp:9960
bool has_destination_activity() const
bool is_auto_moving() const
void start_destination_activity()
action_id get_next_auto_move_direction()
const pathfinding_settings & get_pathfinding_settings() const override
Returns settings for pathfinding.
Definition: character.cpp:9974
bool is_armed() const
Returns true if the character is wielding something.
Definition: melee.cpp:145
void dismount()
Definition: character.cpp:1247
item weapon
Definition: character.h:1529
void set_value(const std::string &key, const std::string &value)
Definition: creature.cpp:1328
std::string get_value(const std::string &key) const
Definition: creature.cpp:1338
void mod_moves(int nmoves)
Definition: creature.cpp:1405
void cycle_move_mode()
Definition: avatar.cpp:1173
void toggle_map_memory()
Definition: avatar.cpp:119
void toggle_crouch_mode()
Definition: avatar.cpp:1157
void toggle_run_mode()
Definition: avatar.cpp:1148
void disp_morale()
Provides the window and detailed morale data.
Definition: avatar.cpp:988
void reset_move_mode()
Definition: avatar.cpp:1166
void item_action_menu()
void display_radiation()
Definition: game.cpp:11782
void list_missions()
Definition: mission_ui.cpp:22
input_context get_player_input(std::string &action)
bool try_get_left_click_action(action_id &act, const tripoint &mouse_target)
Definition: game.cpp:2618
void wield()
Definition: game.cpp:9111
void set_safe_mode(safe_mode_type mode)
Definition: game.cpp:9184
void reload_wielded(bool prompt=false)
Definition: game.cpp:8944
cata::optional< tripoint > look_around()
Definition: game.cpp:6852
void pickup_feet()
Definition: game.cpp:5909
void zones_manager()
Definition: game.cpp:6377
int turnssincelastmon
Definition: game.h:1069
void display_visibility()
Definition: game.cpp:11696
void display_scent()
Definition: game.cpp:11661
bool save()
Returns false if saving failed.
Definition: game.cpp:3111
void butcher()
Definition: game.cpp:8571
void display_temperature()
Definition: game.cpp:11682
bool auto_travel_mode
Definition: game.h:1066
void zoom_out()
Definition: game.cpp:7319
void toggle_pixel_minimap()
Definition: game.cpp:510
void toggle_debug_hour_timer()
Definition: game.cpp:11728
void display_transparency()
Definition: game.cpp:11789
void list_items_monsters()
Definition: game.cpp:7496
void chat()
Definition: npctalk.cpp:394
void quickload()
Definition: game.cpp:11824
void pickup()
Definition: game.cpp:5887
void vertical_move(int z, bool force, bool peeking=false)
Moves the player vertically.
Definition: game.cpp:10509
void open_consume_item_menu()
void display_lighting()
Definition: game.cpp:11756
void control_vehicle()
Definition: game.cpp:5457
void peek()
Definition: game.cpp:5916
void drop()
Definition: game.cpp:8310
bool try_get_right_click_action(action_id &act, const tripoint &mouse_target)
Definition: game.cpp:2646
void reload_weapon(bool try_everything=true)
Definition: game.cpp:8954
bool check_safe_mode_allowed(bool repeat_safe_mode_warnings=true)
Check whether movement is allowed according to safe mode settings.
Definition: game.cpp:9122
void zoom_in()
Definition: game.cpp:7331
void toggle_fullscreen()
Definition: game.cpp:500
void display_vehicle_ai()
Definition: game.cpp:11689
void reload_item()
Definition: game.cpp:8930
void reload_tileset()
Definition: game.cpp:521
void mark_main_ui_adaptor_resize() const
Definition: game.cpp:3359
void drop_in_direction()
Definition: game.cpp:8315
void display_help()
Definition: help.cpp:140
cata::optional< tripoint > get_coordinates(const catacurses::window &capture_win_)
Get the coordinates associated with the last mouse click (if any).
Definition: input.cpp:1338
input_event get_raw_input()
Temporary method to retrieve the raw input received, so that input_contexts can be used in screens wh...
Definition: input.cpp:1299
action_id display_menu(bool permit_execute_action=false)
Displays the possible actions in the current context and their keybindings.
Definition: input.cpp:999
std::string get_keyname(int ch, input_event_t inp_type, bool portable=false) const
Get the key name associated with the given keyboard keycode.
Definition: input.cpp:415
bool is_gun() const
Can this item be used to perform a ranged attack?
Definition: item.cpp:6361
void gun_cycle_mode()
Switch to the next available firing mode.
Definition: item.cpp:7752
std::string display_name(unsigned int quantity=1) const
Returns the item name and the charges or contained charges (if the item can have charges at all).
Definition: item.cpp:4700
bool is_gunmod() const
Definition: item.cpp:6391
std::map< gun_mode_id, gun_mode > gun_all_modes() const
Get all possible modes for this gun inclusive of any attached gunmods.
Definition: item.cpp:7671
bool gun_set_mode(const gun_mode_id &mode)
Try to set the mode for a gun, returning false if no such mode is possible.
Definition: item.cpp:7743
bool is_outside(const tripoint &p) const
Definition: map.cpp:2558
std::vector< tripoint > route(const tripoint &f, const tripoint &t, const pathfinding_settings &settings, const std::set< tripoint > &pre_closed={{ }}) const
Calculate the best path using A*.
const tripoint & pos() const override
Definition: monster.cpp:255
short ignoring
Definition: monster.h:505
cOpt & get_option(const std::string &name)
Definition: options.cpp:3334
std::string show(bool ingame=false, bool world_options_only=false, const std::function< bool()> &on_quit=nullptr)
Definition: options.cpp:2722
void show_adm()
Definition: panels.cpp:2405
void pause()
Definition: player.cpp:651
void craft(const tripoint &loc=tripoint_zero)
Start various types of crafts.
Definition: crafting.cpp:335
void sort_armor()
Draws the UI and handles player input for the armor re-ordering window.
void power_mutations()
Definition: mutation_ui.cpp:89
void use_wielded()
Uses the current wielded weapon.
Definition: player.cpp:3109
int movecounter
Definition: player.h:653
void power_bionics()
Generates and handles the UI for player interaction with installed bionics.
Definition: bionics_ui.cpp:528
void recraft(const tripoint &loc=tripoint_zero)
Definition: crafting.cpp:346
void long_craft(const tripoint &loc=tripoint_zero)
Definition: crafting.cpp:355
void add_rule(const std::string &rule_in, Creature::Attitude attitude_in, int proximity_in, rule_state state_in)
void show()
Definition: safemode_ui.cpp:39
int moves_elapsed()
#define all_colors
Definition: color.h:15
construction_id construction_menu(const bool blueprint)
@ Info
Information (default: enabled).
@ RULE_WHITELISTED
Definition: enums.h:53
@ SAFE_MODE_OFF
Definition: game.h:77
@ QUIT_SAVED
Definition: game.h:70
static void open_movement_mode_menu()
static void smash()
static void open()
#define dbg(x)
static void takeoff()
static void read()
static void wait()
static const efftype_id effect_laserlocked("laserlocked")
static void rcdrive(const point &d)
static void wear()
static void close()
static const bionic_id bio_remote("bio_remote")
static void pldrive(const tripoint &p)
static void haul()
static const trait_id trait_SHELL2("SHELL2")
static const trait_id trait_PROF_CHURL("PROF_CHURL")
static void cast_spell()
static void loot()
static void fire()
static void grab()
static void sleep()
static const itype_id itype_radiocontrol("radiocontrol")
help & get_help()
Definition: help.cpp:30
bool isDebugger()
Definition: mapsharing.cpp:65
bool isCompetitive()
Definition: mapsharing.cpp:35
void use_item(avatar &you, item_location &loc)
bool eat_here(avatar &you)
void autoattack(avatar &you, map &m)
void eat(avatar &you)
Eat food or fuel 'E' (or 'a')
void fire_wielded_weapon(avatar &you)
Checks if the wielded weapon is a gun and can be fired then starts interactive aiming.
void plthrow(avatar &you, item_location loc, const cata::optional< tripoint > &blind_throw_from_pos=cata::nullopt)
void mend(avatar &you, item_location loc)
void unload(avatar &you)
void disp_info(Character &ch)
Handles and displays detailed character info for the '@' screen.
void debug()
void close_door(map &m, Character &who, const tripoint &closep)
Handles deducting moves, printing messages (only non-NPCs cause messages), actually closing it,...
Definition: gates.cpp:256
void compare(player &p, const cata::optional< tripoint > &offset)
void common(avatar &you)
void swap_letters(player &p)
void prompt_select_default_ammo_for(avatar &u, const item &w)
Prompts to select default ammo compatible with provided gun.
Definition: ranged.cpp:3743
void display_visible_weather()
Display overmap like with display() and display the weather that is within line of sight.
void display()
Display overmap centered at the player's position.
options_manager & get_options()
Definition: options.cpp:142
T get_option(const std::string &name)
Definition: options.h:368
static constexpr point point_south_west
Definition: point.h:281
static constexpr point point_north_east
Definition: point.h:277
static constexpr point point_north_west
Definition: point.h:283
An instance of an input, like a keypress etc.
Definition: input.h:95
std::vector< int > sequence
Definition: input.h:101
int get_first_input() const
Definition: input.cpp:100
input_event_t type
Definition: input.h:96
void handbrake()

References _, Creature::A_ANY, achievements_tracker_ptr, act, action, ACTION_ACTIONMENU, ACTION_ADVANCEDINV, ACTION_AUTOATTACK, ACTION_AUTONOTES, ACTION_AUTOPICKUP, ACTION_BIONICS, ACTION_BUTCHER, ACTION_CAST_SPELL, ACTION_CENTER, ACTION_CHAT, ACTION_CLOSE, ACTION_COLOR, ACTION_COMPARE, ACTION_CONSTRUCT, ACTION_CONTROL_VEHICLE, ACTION_CRAFT, ACTION_CYCLE_MOVE, ACTION_DEBUG, ACTION_DIR_DROP, ACTION_DISASSEMBLE, ACTION_DISPLAY_LIGHTING, ACTION_DISPLAY_RADIATION, ACTION_DISPLAY_SCENT, ACTION_DISPLAY_SCENT_TYPE, ACTION_DISPLAY_SUBMAP_GRID, ACTION_DISPLAY_TEMPERATURE, ACTION_DISPLAY_TRANSPARENCY, ACTION_DISPLAY_VEHICLE_AI, ACTION_DISPLAY_VISIBILITY, ACTION_DROP, ACTION_EAT, ACTION_EXAMINE, ACTION_FACTIONS, ACTION_FIRE, ACTION_FIRE_BURST, ACTION_GRAB, ACTION_HAUL, ACTION_HELP, action_ident(), ACTION_IGNORE_ENEMY, ACTION_INVENTORY, ACTION_ITEMACTION, ACTION_KEYBINDINGS, ACTION_LIST_ITEMS, ACTION_LONGCRAFT, ACTION_LOOK, ACTION_LOOT, ACTION_MAIN_MENU, ACTION_MAP, ACTION_MEND, ACTION_MESSAGES, ACTION_MISSIONS, ACTION_MORALE, ACTION_MOVE_BACK, ACTION_MOVE_BACK_LEFT, ACTION_MOVE_BACK_RIGHT, ACTION_MOVE_DOWN, ACTION_MOVE_FORTH, ACTION_MOVE_FORTH_LEFT, ACTION_MOVE_FORTH_RIGHT, ACTION_MOVE_LEFT, ACTION_MOVE_RIGHT, ACTION_MOVE_UP, ACTION_MUTATIONS, ACTION_NULL, ACTION_OPEN, ACTION_OPEN_CONSUME, ACTION_OPEN_MOVEMENT, ACTION_OPTIONS, ACTION_ORGANIZE, ACTION_PAUSE, ACTION_PEEK, ACTION_PICK_STYLE, ACTION_PICKUP, ACTION_PICKUP_FEET, ACTION_PL_INFO, ACTION_QUICKLOAD, ACTION_QUICKSAVE, ACTION_READ, ACTION_RECRAFT, ACTION_RELOAD_ITEM, ACTION_RELOAD_TILESET, ACTION_RELOAD_WEAPON, ACTION_RELOAD_WIELDED, ACTION_RESET_MOVE, ACTION_SAFEMODE, ACTION_SAVE, ACTION_SCORES, ACTION_SEC_SELECT, ACTION_SELECT, ACTION_SELECT_DEFAULT_AMMO, ACTION_SELECT_FIRE_MODE, ACTION_SHIFT_E, ACTION_SHIFT_N, ACTION_SHIFT_NE, ACTION_SHIFT_NW, ACTION_SHIFT_S, ACTION_SHIFT_SE, ACTION_SHIFT_SW, ACTION_SHIFT_W, ACTION_SKY, ACTION_SLEEP, ACTION_SMASH, ACTION_SORT_ARMOR, ACTION_SUICIDE, ACTION_TAKE_OFF, ACTION_THROW, ACTION_TIMEOUT, ACTION_TOGGLE_AUTO_FEATURES, ACTION_TOGGLE_AUTO_FORAGING, ACTION_TOGGLE_AUTO_MINING, ACTION_TOGGLE_AUTO_PICKUP, ACTION_TOGGLE_AUTO_PULP_BUTCHER, ACTION_TOGGLE_AUTO_TRAVEL_MODE, ACTION_TOGGLE_AUTOSAFE, ACTION_TOGGLE_CROUCH, ACTION_TOGGLE_DEBUG_MODE, ACTION_TOGGLE_FULLSCREEN, ACTION_TOGGLE_HOUR_TIMER, ACTION_TOGGLE_MAP_MEMORY, ACTION_TOGGLE_PANEL_ADM, ACTION_TOGGLE_PIXEL_MINIMAP, ACTION_TOGGLE_RUN, ACTION_TOGGLE_SAFEMODE, ACTION_TOGGLE_THIEF_MODE, ACTION_UNLOAD, ACTION_USE, ACTION_USE_WIELDED, ACTION_WAIT, ACTION_WEAR, ACTION_WHITELIST_ENEMY, ACTION_WIELD, ACTION_WORLD_MODS, ACTION_ZONES, ACTION_ZOOM_IN, ACTION_ZOOM_OUT, add_msg(), safemode::add_rule(), all_colors, auto_travel_mode, avatar_action::autoattack(), bio_remote, butcher(), can_action_change_worldstate(), cast_spell(), chat(), check_safe_mode_allowed(), Character::clear_destination(), close(), doors::close_door(), game_menus::inv::common(), game_menus::inv::compare(), construction_menu(), control_vehicle(), Character::controlling_vehicle, player::craft(), create_advanced_inv(), avatar::cycle_move_mode(), dbg, debug_menu::debug(), debug_mode, destination_preview, player::disassemble(), Character::dismount(), character_display::disp_info(), avatar::disp_morale(), ui::omap::display(), help::display_help(), display_lighting(), input_context::display_menu(), Messages::display_messages(), item::display_name(), display_radiation(), display_scent(), display_temperature(), display_transparency(), display_vehicle_ai(), display_visibility(), ui::omap::display_visible_weather(), driving_view_offset, drop(), drop_in_direction(), avatar_action::eat(), avatar_action::eat_here(), effect_laserlocked, examine(), faction_manager_ptr, fire(), avatar_action::fire_wielded_weapon(), g, gamemode, get_auto_notes_settings(), get_auto_pickup(), input_context::get_coordinates(), get_delta_from_movement_action(), input_event::get_first_input(), get_help(), input_manager::get_keyname(), get_kill_tracker(), panel_manager::get_manager(), avatar::get_mon_visible(), Character::get_next_auto_move_direction(), options_manager::get_option(), get_option(), get_options(), Character::get_path_avoid(), Character::get_pathfinding_settings(), get_player_input(), input_context::get_raw_input(), get_safemode(), Creature::get_value(), grab(), item::gun_all_modes(), item::gun_cycle_mode(), item::gun_set_mode(), handbrake(), handle_action_menu(), handle_main_menu(), Character::has_active_bionic(), Character::has_active_item(), Character::has_active_mutation(), Character::has_destination(), Character::has_destination_activity(), Creature::has_effect(), Character::has_trait(), haul(), monster::ignoring, Character::in_vehicle, Info, inp_mngr, Character::is_armed(), Character::is_auto_moving(), player::is_dead_state(), item::is_gun(), item::is_gunmod(), Character::is_mounted(), map::is_outside(), MAP_SHARING::isCompetitive(), MAP_SHARING::isDebugger(), item_action_menu(), itype_radiocontrol, list_items_monsters(), list_missions(), player::long_craft(), look_around(), look_up_action(), loot(), m, m_bad, m_info, m_warning, mark_main_ui_adaptor_resize(), Character::martial_arts_data, avatar_action::mend(), MF_RIDEABLE_MECH, Creature::mod_moves(), mostseen, Character::mounted_creature, avatar_action::move(), player::movecounter, Creature::moves, user_turn::moves_elapsed(), om_direction::name(), monster_visible_info::new_seen_mon, no, cata::nullopt, NUM_ACTIONS, open(), open_consume_item_menu(), open_movement_mode_menu(), player::pause(), peek(), pickup(), pickup_feet(), Character::place_corpse(), pldrive(), avatar_action::plthrow(), point_east, point_north, point_north_east, point_north_west, point_south, point_south_east, point_south_west, point_west, point_zero, Character::pos(), monster::pos(), Character::posx(), Character::posy(), Character::posz(), player::power_bionics(), player::power_mutations(), press_x(), press_x_if_bound(), ranged::prompt_select_default_ammo_for(), query_yn(), quickload(), quicksave(), QUIT_DIED, QUIT_SAVED, QUIT_SUICIDE, QUIT_WATCH, rcdrive(), read(), player::recraft(), reload_item(), reload_tileset(), reload_weapon(), reload_wielded(), remoteveh(), Creature::remove_effect(), avatar::reset_move_mode(), rl_dist(), map::route(), RULE_WHITELISTED, safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAFE_MODE_STOP, safe_mode_warning_logged, save(), options_manager::save(), Character::sees(), SEEX, input_event::sequence, Character::set_destination(), set_safe_mode(), Creature::set_value(), options_manager::cOpt::setNext(), auto_pickup::player_settings::show(), safemode::show(), options_manager::show(), panel_manager::show_adm(), auto_notes::auto_note_settings::show_gui(), show_scores_ui(), sleep(), smash(), player::sort_armor(), Character::start_destination_activity(), stats(), string_format(), game_menus::inv::swap_letters(), takeoff(), tile_iso, avatar::toggle_crouch_mode(), toggle_debug_hour_timer(), toggle_fullscreen(), avatar::toggle_map_memory(), toggle_pixel_minimap(), avatar::toggle_run_mode(), trait_PROF_CHURL, trait_SHELL2, tripoint_above, tripoint_below, try_get_left_click_action(), try_get_right_click_action(), calendar::turn, turnssincelastmon, input_event::type, u, avatar_action::unload(), uquit, avatar_action::use_item(), use_tiles, player::use_wielded(), user_action_counter, map::veh_at(), vertical_move(), player::view_offset, w_terrain, wait(), Character::weapon, wear(), wield(), world_generator, point::x, tripoint::x, point::y, tripoint::y, yes, zones_manager(), zoom_in(), and zoom_out().

Referenced by do_turn().

◆ handle_key_blocking_activity()

void game::handle_key_blocking_activity ( )
private

Definition at line 2057 of file game.cpp.

2058{
2060 const std::string action = ctxt.handle_input( 0 );
2061 bool refresh = true;
2062 if( action == "pause" ) {
2064 cancel_activity_query( _( "Confirm:" ) );
2065 }
2066 } else if( action == "player_data" ) {
2068 } else if( action == "messages" ) {
2070 } else if( action == "help" ) {
2072 } else if( action != "HELP_KEYBINDINGS" ) {
2073 refresh = false;
2074 }
2075 if( refresh ) {
2078 }
2079}
bool cancel_activity_query(const std::string &text)
Asks if the player wants to cancel their activity, and if so cancels it.
Definition: game.cpp:1841
const std::string & handle_input()
Handles input and returns the next action in the queue.
Definition: input.cpp:854
bool interruptable_with_kb
Controls whether this activity can be cancelled with 'pause' action.
void refresh()

References _, action, Character::activity, cancel_activity_query(), character_display::disp_info(), help::display_help(), Messages::display_messages(), get_default_mode_input_context(), get_help(), input_context::handle_input(), player_activity::interruptable_with_kb, ui_manager::redraw(), catacurses::refresh(), refresh_display(), and u.

Referenced by process_voluntary_act_interrupt().

◆ handle_mouseview()

bool game::handle_mouseview ( input_context ctxt,
std::string &  action 
)
private

Definition at line 2325 of file game.cpp.

2326{
2327 cata::optional<tripoint> liveview_pos;
2328
2329 do {
2330 action = ctxt.handle_input();
2331 if( action == "MOUSE_MOVE" ) {
2332 const cata::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
2333 if( mouse_pos && ( !liveview_pos || *mouse_pos != *liveview_pos ) ) {
2334 liveview_pos = mouse_pos;
2335 liveview.show( *liveview_pos );
2336 } else if( !mouse_pos ) {
2337 liveview_pos.reset();
2338 liveview.hide();
2339 }
2341 }
2342 } while( action == "MOUSE_MOVE" ); // Freeze animation when moving the mouse
2343
2344 if( action != "TIMEOUT" ) {
2345 // Keyboard event, break out of animation loop
2346 liveview.hide();
2347 return false;
2348 }
2349
2350 // Mouse movement or un-handled key
2351 return true;
2352}
void reset() noexcept
Definition: optional.h:155
void hide()
Definition: live_view.cpp:33
void show(const tripoint &p)
Definition: live_view.cpp:38

References action, input_context::get_coordinates(), input_context::handle_input(), live_view::hide(), liveview, ui_manager::redraw(), cata::optional< T >::reset(), live_view::show(), and w_terrain.

Referenced by get_player_input().

◆ has_gametype()

bool game::has_gametype ( ) const

Definition at line 624 of file game.cpp.

625{
626 return gamemode && gamemode->id() != SGAME_NULL;
627}

References gamemode, and SGAME_NULL.

◆ init_autosave()

void game::init_autosave ( )
private

Definition at line 11796 of file game.cpp.

11797{
11799 last_save_timestamp = time( nullptr );
11800}

References last_save_timestamp, and moves_since_last_save.

Referenced by load(), and start_game().

◆ inv_map_splice()

item_location game::inv_map_splice ( item_filter  filter,
const std::string &  title,
int  radius = 0,
const std::string &  none_message = "" 
)

Custom-filtered menu for inventory and nearby items and those that within specified radius.

Definition at line 391 of file game_inventory.cpp.

393{
395 title, radius, none_message );
396}
static item_location_filter convert_filter(const item_filter &filter)
static item_location inv_internal(player &u, const inventory_selector_preset &preset, const std::string &title, int radius, const std::string &none_message, const std::string &hint=std::string())
std::string title(holiday current_holiday)
Definition: path_info.cpp:330

References convert_filter(), inv_internal(), PATH_INFO::title(), and u.

Referenced by reload_item().

◆ invalidate_main_ui_adaptor()

void game::invalidate_main_ui_adaptor ( ) const

◆ inventory_item_menu()

int game::inventory_item_menu ( item_location  locThisItem,
const std::function< int()> &  startx = []() { return 0; },
const std::function< int()> &  width = []() { return 50; },
inventory_item_menu_positon  position = RIGHT_OF_INFO 
)

Definition at line 2089 of file game.cpp.

2093{
2094 int cMenu = static_cast<int>( '+' );
2095
2096 item &oThisItem = *locThisItem;
2097 if( u.has_item( oThisItem ) ) {
2098#if defined(__ANDROID__)
2099 if( get_option<bool>( "ANDROID_INVENTORY_AUTOADD" ) ) {
2100 add_key_to_quick_shortcuts( oThisItem.invlet, "INVENTORY", false );
2101 }
2102#endif
2103
2104 std::vector<iteminfo> vThisItem;
2105 std::vector<iteminfo> vDummy;
2106
2107 const bool bHPR = get_auto_pickup().has_rule( &oThisItem );
2108 const bool is_wielded = u.is_wielding( oThisItem );
2109 const bool cant_unwield_if_weapon = is_wielded && !u.can_unwield( oThisItem ).success();
2110 const bool cant_unwield_existing_weapon = u.is_armed() && !u.can_unwield( u.weapon ).success();
2111 const bool cant_takeoff_if_worn = u.is_wearing( oThisItem ) &&
2112 !u.can_takeoff( oThisItem ).success();
2113 const bool cant_dispose_of = cant_unwield_if_weapon || cant_takeoff_if_worn;
2114 const bool cant_acquare = cant_unwield_existing_weapon || cant_takeoff_if_worn;
2115 const hint_rating rate_unwield_item = cant_dispose_of ? hint_rating::cant :
2117 const hint_rating rate_wield_item = cant_acquare ? hint_rating::cant :
2119 const hint_rating rate_drop_item = cant_dispose_of ? hint_rating::cant :
2121
2122 uilist action_menu;
2123 action_menu.allow_anykey = true;
2124 const auto addentry = [&]( const char key, const std::string & text, const hint_rating hint ) {
2125 // The char is used as retval from the uilist *and* as hotkey.
2126 action_menu.addentry( key, true, key, text );
2127 auto &entry = action_menu.entries.back();
2128 switch( hint ) {
2129 case hint_rating::cant:
2130 entry.text_color = c_light_gray;
2131 break;
2132 case hint_rating::iffy:
2133 entry.text_color = c_light_red;
2134 break;
2135 case hint_rating::good:
2136 entry.text_color = c_light_green;
2137 break;
2138 }
2139 };
2140 addentry( 'a', pgettext( "action", "activate" ), u.rate_action_use( oThisItem ) );
2141 addentry( 'R', pgettext( "action", "read" ), u.rate_action_read( oThisItem ) );
2142 addentry( 'E', pgettext( "action", "eat" ), u.rate_action_eat( oThisItem ) );
2143 addentry( 'W', pgettext( "action", "wear" ), u.rate_action_wear( oThisItem ) );
2144 if( is_wielded ) {
2145 addentry( 'w', pgettext( "action", "unwield" ), rate_unwield_item );
2146 } else {
2147 addentry( 'w', pgettext( "action", "wield" ), rate_wield_item );
2148 }
2149 addentry( 't', pgettext( "action", "throw" ), rate_drop_item );
2150 addentry( 'c', pgettext( "action", "change side" ), u.rate_action_change_side( oThisItem ) );
2151 addentry( 'T', pgettext( "action", "take off" ), u.rate_action_takeoff( oThisItem ) );
2152 addentry( 'd', pgettext( "action", "drop" ), rate_drop_item );
2153 addentry( 'U', pgettext( "action", "unload" ), u.rate_action_unload( oThisItem ) );
2154 addentry( 'r', pgettext( "action", "reload" ), u.rate_action_reload( oThisItem ) );
2155 addentry( 'p', pgettext( "action", "part reload" ), u.rate_action_reload( oThisItem ) );
2156 addentry( 'm', pgettext( "action", "mend" ), u.rate_action_mend( oThisItem ) );
2157 addentry( 'D', pgettext( "action", "disassemble" ), u.rate_action_disassemble( oThisItem ) );
2158
2159 if( oThisItem.is_favorite ) {
2160 addentry( 'f', pgettext( "action", "unfavorite" ), hint_rating::good );
2161 } else {
2162 addentry( 'f', pgettext( "action", "favorite" ), hint_rating::good );
2163 }
2164
2165 addentry( '=', pgettext( "action", "reassign" ), hint_rating::good );
2166
2167 if( bHPR ) {
2168 addentry( '-', _( "Autopickup" ), hint_rating::iffy );
2169 } else {
2170 addentry( '+', _( "Autopickup" ), hint_rating::good );
2171 }
2172
2173 int iScrollPos = 0;
2174 oThisItem.info( true, vThisItem );
2175
2176 action_menu.w_y_setup = 0;
2177 action_menu.w_x_setup = [&]( const int popup_width ) -> int {
2178 switch( position )
2179 {
2180 default:
2182 return 0;
2183 case LEFT_OF_INFO:
2184 return iStartX() - popup_width;
2185 case RIGHT_OF_INFO:
2186 return iStartX() + iWidth();
2187 case LEFT_TERMINAL_EDGE:
2188 return TERMX - popup_width;
2189 }
2190 };
2191 // Filtering isn't needed, the number of entries is manageable.
2192 action_menu.filtering = false;
2193 // Default menu border color is different, this matches the border of the item info window.
2194 action_menu.border_color = BORDER_COLOR;
2195
2196 item_info_data data( oThisItem.tname(), oThisItem.type_name(), vThisItem, vDummy, iScrollPos );
2197 data.without_getch = true;
2198
2199 catacurses::window w_info;
2200 int iScrollHeight = 0;
2201
2202 std::unique_ptr<ui_adaptor> ui = std::make_unique<ui_adaptor>();
2203 ui->on_screen_resize( [&]( ui_adaptor & ui ) {
2204 w_info = catacurses::newwin( TERMY, iWidth(), point( iStartX(), 0 ) );
2205 iScrollHeight = TERMY - 2;
2206 ui.position_from_window( w_info );
2207 } );
2208 ui->mark_resize();
2209
2210 ui->on_redraw( [&]( const ui_adaptor & ) {
2211 draw_item_info( w_info, data );
2212 } );
2213
2214 bool exit = false;
2215 do {
2216 const int prev_selected = action_menu.selected;
2217 action_menu.query( false );
2218 if( action_menu.ret >= 0 ) {
2219 cMenu = action_menu.ret; /* Remember: hotkey == retval, see addentry above. */
2220 } else if( action_menu.ret == UILIST_UNBOUND && action_menu.keypress == KEY_RIGHT ) {
2221 // Simulate KEY_RIGHT == '\n' (confirm currently selected entry) for compatibility with old version.
2222 // TODO: ideally this should be done in the uilist, maybe via a callback.
2223 cMenu = action_menu.ret = action_menu.entries[action_menu.selected].retval;
2224 } else if( action_menu.keypress == KEY_PPAGE || action_menu.keypress == KEY_NPAGE ) {
2225 cMenu = action_menu.keypress;
2226 // Prevent the menu from scrolling with this key. TODO: Ideally the menu
2227 // could be instructed to ignore these two keys instead of scrolling.
2228 action_menu.selected = prev_selected;
2229 action_menu.fselected = prev_selected;
2230 action_menu.vshift = 0;
2231 } else {
2232 cMenu = 0;
2233 }
2234
2235 if( action_menu.ret != UILIST_WAIT_INPUT && action_menu.ret != UILIST_UNBOUND ) {
2236 exit = true;
2237 ui = nullptr;
2238 }
2239
2240 switch( cMenu ) {
2241 case 'a':
2242 avatar_action::use_item( u, locThisItem );
2243 break;
2244 case 'E':
2245 avatar_action::eat( u, locThisItem );
2246 break;
2247 case 'W':
2248 u.wear( oThisItem );
2249 break;
2250 case 'w':
2251 wield( locThisItem );
2252 break;
2253 case 't':
2254 avatar_action::plthrow( u, locThisItem );
2255 break;
2256 case 'c':
2257 u.change_side( locThisItem );
2258 break;
2259 case 'T':
2260 u.takeoff( oThisItem );
2261 break;
2262 case 'd':
2263 u.drop( locThisItem, u.pos() );
2264 break;
2265 case 'U':
2266 unload( locThisItem );
2267 break;
2268 case 'r':
2269 reload( locThisItem );
2270 break;
2271 case 'p':
2272 reload( locThisItem, true );
2273 break;
2274 case 'm':
2275 avatar_action::mend( u, locThisItem );
2276 break;
2277 case 'R':
2278 u.read( locThisItem );
2279 break;
2280 case 'D':
2281 u.disassemble( locThisItem, false );
2282 break;
2283 case 'f':
2284 oThisItem.is_favorite = !oThisItem.is_favorite;
2285 break;
2286 case '=':
2287 game_menus::inv::reassign_letter( u, oThisItem );
2288 break;
2289 case KEY_PPAGE:
2290 iScrollPos -= iScrollHeight;
2291 if( ui ) {
2292 ui->invalidate_ui();
2293 }
2294 break;
2295 case KEY_NPAGE:
2296 iScrollPos += iScrollHeight;
2297 if( ui ) {
2298 ui->invalidate_ui();
2299 }
2300 break;
2301 case '+':
2302 if( !bHPR ) {
2303 get_auto_pickup().add_rule( &oThisItem );
2304 add_msg( m_info, _( "'%s' added to character pickup rules." ), oThisItem.tname( 1,
2305 false ) );
2306 }
2307 break;
2308 case '-':
2309 if( bHPR ) {
2310 get_auto_pickup().remove_rule( &oThisItem );
2311 add_msg( m_info, _( "'%s' removed from character pickup rules." ), oThisItem.tname( 1,
2312 false ) );
2313 }
2314 break;
2315 default:
2316 break;
2317 }
2318 } while( !exit );
2319 }
2320 return cMenu;
2321}
hint_rating rate_action_change_side(const item &it) const
Used to determine player feedback on item use for the inventory code.
Definition: character.cpp:3698
bool is_wielding(const item &target) const
Definition: character.cpp:3238
bool change_side(item &it, bool interactive=true)
Swap side on which item is worn; returns false on fail.
Definition: character.cpp:3711
ret_val< bool > can_unwield(const item &it) const
Check player capable of unwielding an item.
Definition: character.cpp:3158
bool is_wearing(const item &itm) const
Returns true if the player is wearing the item.
Definition: character.cpp:3243
hint_rating rate_action_eat(const item &it) const
void remove_rule(const item *it)
bool has_rule(const item *it)
void add_rule(const item *it)
hint_rating rate_action_read(const item &it) const
Definition: avatar.cpp:936
bool read(item_location loc, bool continuous=false)
Handles reading effects and returns true if activity started.
Definition: avatar.cpp:369
bool unload(item_location loc)
Definition: game.cpp:9018
void reload(item_location &loc, bool prompt=false, bool empty=true)
Definition: game.cpp:8846
bool is_favorite
Definition: item.h:2234
std::string info(bool showtext=false) const
Return all the information about the item and its type.
Definition: item.cpp:1103
std::string type_name(unsigned int quantity=1) const
Name of the item type (not the item), with proper plural.
Definition: item.cpp:9672
std::string tname(unsigned int quantity=1, bool with_prefix=true, unsigned int truncate=0) const
Return the (translated) item name.
Definition: item.cpp:4438
char invlet
Definition: item.h:2232
hint_rating rate_action_mend(const item &it) const
Definition: player.cpp:3176
cata::optional< std::list< item >::iterator > wear(int pos, bool interactive=true)
Wear item; returns false on fail.
Definition: player.cpp:2753
hint_rating rate_action_takeoff(const item &it) const
Definition: player.cpp:2803
hint_rating rate_action_reload(const item &it) const
Definition: player.cpp:3114
hint_rating rate_action_wear(const item &it) const
Definition: player.cpp:2518
hint_rating rate_action_disassemble(const item &it)
Definition: player.cpp:3185
ret_val< bool > can_takeoff(const item &it, const std::list< item > *res=nullptr) const
Check player capable of taking off an item.
Definition: player.cpp:2833
hint_rating rate_action_unload(const item &it) const
Definition: player.cpp:3139
bool takeoff(item &it, std::list< item > *res=nullptr)
Takes off an item, returning false on fail.
Definition: player.cpp:2857
hint_rating rate_action_use(const item &it) const
Used to determine player feedback on item use for the inventory code.
Definition: player.cpp:3198
nc_color border_color
Definition: ui.h:328
int keypress
Definition: ui.h:413
bool filtering
Definition: ui.h:354
pos_scalar w_x_setup
Definition: ui.h:337
int fselected
Definition: ui.h:388
int selected
Definition: ui.h:415
bool allow_anykey
Definition: ui.h:360
int vshift
Definition: ui.h:386
std::vector< uilist_entry > entries
Definition: ui.h:323
bool has_item(const item &it) const
Returns true if this visitable instance contains the item.
Definition: visitable.cpp:95
static constexpr int KEY_NPAGE
Definition: input.h:65
static constexpr int KEY_PPAGE
Definition: input.h:66
static constexpr int KEY_RIGHT
Definition: input.h:40
hint_rating
Hint value used in a hack to decide text color.
Definition: item.h:2257
@ iffy
Item should display as red.
@ good
Item should display as green.
@ cant
Item should display as gray.
void reassign_letter(player &p, item &it)
input_event draw_item_info(const int iLeft, const int iWidth, const int iTop, const int iHeight, item_info_data &data)
Definition: output.cpp:793
#define BORDER_COLOR
Definition: output.h:135
const int UILIST_UNBOUND
Definition: ui.h:27
const int UILIST_WAIT_INPUT
Definition: ui.h:26

References _, add_msg(), auto_pickup::player_settings::add_rule(), uilist::addentry(), uilist::allow_anykey, BORDER_COLOR, uilist::border_color, c_light_gray, c_light_green, c_light_red, player::can_takeoff(), Character::can_unwield(), cant, Character::change_side(), player::disassemble(), draw_item_info(), Character::drop(), avatar_action::eat(), uilist::entries, uilist::filtering, uilist::fselected, get_auto_pickup(), good, visitable< T >::has_item(), auto_pickup::player_settings::has_rule(), iffy, item::info(), item::invlet, Character::is_armed(), item::is_favorite, Character::is_wearing(), Character::is_wielding(), KEY_NPAGE, KEY_PPAGE, KEY_RIGHT, uilist::keypress, LEFT_OF_INFO, LEFT_TERMINAL_EDGE, m_info, avatar_action::mend(), catacurses::newwin(), pgettext(), avatar_action::plthrow(), Character::pos(), uilist::query(), Character::rate_action_change_side(), player::rate_action_disassemble(), Character::rate_action_eat(), player::rate_action_mend(), avatar::rate_action_read(), player::rate_action_reload(), player::rate_action_takeoff(), player::rate_action_unload(), player::rate_action_use(), player::rate_action_wear(), avatar::read(), game_menus::inv::reassign_letter(), reload(), auto_pickup::player_settings::remove_rule(), uilist::ret, RIGHT_OF_INFO, RIGHT_TERMINAL_EDGE, uilist::selected, player::takeoff(), TERMX, TERMY, item::tname(), item::type_name(), u, UILIST_UNBOUND, UILIST_WAIT_INPUT, unload(), avatar_action::use_item(), uilist::vshift, uilist::w_x_setup, uilist::w_y_setup, Character::weapon, player::wear(), wield(), and item_info_data::without_getch.

◆ is_core_data_loaded()

bool game::is_core_data_loaded ( ) const

Returns whether the core data is currently loaded.

Definition at line 433 of file game.cpp.

434{
436}
bool is_data_finalized() const
Returns whether the data is finalized and ready to be utilized.
Definition: init.h:167

References DynamicDataLoader::get_instance(), and DynamicDataLoader::is_data_finalized().

◆ is_dangerous_tile()

bool game::is_dangerous_tile ( const tripoint dest_loc) const

Definition at line 9251 of file game.cpp.

9252{
9253 return !( get_dangerous_tile( dest_loc ).empty() );
9254}
std::vector< std::string > get_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:9273

References get_dangerous_tile().

Referenced by walk_move().

◆ is_empty()

bool game::is_empty ( const tripoint p)

Returns true if there is no player, NPC, or monster on the tile and move_cost > 0.

Definition at line 5153 of file game.cpp.

5154{
5155 return ( m.passable( p ) || m.has_flag( "LIQUID", p ) ) &&
5156 critter_at( p ) == nullptr;
5157}

References critter_at(), map::has_flag(), m, and map::passable().

Referenced by grabbed_furn_move(), monmove(), place_player(), and update_stair_monsters().

◆ is_game_over()

bool game::is_game_over ( )
private

Definition at line 2691 of file game.cpp.

2692{
2693 if( uquit == QUIT_WATCH ) {
2694 // deny player movement and dodging
2695 u.moves = 0;
2696 // prevent pain from updating
2697 u.set_pain( 0 );
2698 // prevent dodging
2699 u.dodges_left = 0;
2700 return false;
2701 }
2702 if( uquit == QUIT_DIED ) {
2703 if( u.in_vehicle ) {
2704 m.unboard_vehicle( u.pos() );
2705 }
2706 u.place_corpse();
2707 return true;
2708 }
2709 if( uquit == QUIT_SUICIDE ) {
2710 if( u.in_vehicle ) {
2711 m.unboard_vehicle( u.pos() );
2712 }
2713 return true;
2714 }
2715 if( uquit != QUIT_NO ) {
2716 return true;
2717 }
2718 // is_dead_state() already checks hp_torso && hp_head, no need to for loop it
2719 if( u.is_dead_state() ) {
2721 if( get_option<std::string>( "DEATHCAM" ) == "always" ) {
2722 uquit = QUIT_WATCH;
2723 } else if( get_option<std::string>( "DEATHCAM" ) == "ask" ) {
2724 uquit = query_yn( _( "Watch the last moments of your life…?" ) ) ?
2726 } else if( get_option<std::string>( "DEATHCAM" ) == "never" ) {
2727 uquit = QUIT_DIED;
2728 } else {
2729 // Something funky happened here, just die.
2730 dbg( DL::Error ) << "no deathcam option given to options, defaulting to QUIT_DIED";
2731 uquit = QUIT_DIED;
2732 }
2733 return is_game_over();
2734 }
2735 return false;
2736}
int dodges_left
Definition: character.h:558
void set_pain(int npain) override
Sets new intensity of pain an reacts to it.
Definition: player.cpp:1014
@ Error
Error (default: enabled).
#define dbg(x)
Definition: game.cpp:189
void deactivate()
Definition: messages.cpp:357

References _, dbg, Messages::deactivate(), Character::dodges_left, Error, Character::in_vehicle, player::is_dead_state(), is_game_over(), m, Creature::moves, Character::place_corpse(), Character::pos(), query_yn(), QUIT_DIED, QUIT_NO, QUIT_SUICIDE, QUIT_WATCH, player::set_pain(), u, map::unboard_vehicle(), and uquit.

Referenced by do_turn(), and is_game_over().

◆ is_hostile_nearby()

Creature * game::is_hostile_nearby ( )

Definition at line 3950 of file game.cpp.

3951{
3952 int distance = ( get_option<int>( "SAFEMODEPROXIMITY" ) <= 0 ) ? MAX_VIEW_DISTANCE :
3953 get_option<int>( "SAFEMODEPROXIMITY" );
3954 return is_hostile_within( distance );
3955}
Creature * is_hostile_within(int distance)
Definition: game.cpp:3962

References is_hostile_within(), and MAX_VIEW_DISTANCE.

◆ is_hostile_very_close()

Creature * game::is_hostile_very_close ( )

Definition at line 3957 of file game.cpp.

3958{
3960}
static constexpr int DANGEROUS_PROXIMITY
Definition: game.cpp:191

References DANGEROUS_PROXIMITY, and is_hostile_within().

Referenced by butcher(), and process_voluntary_act_interrupt().

◆ is_hostile_within()

Creature * game::is_hostile_within ( int  distance)
private

Definition at line 3962 of file game.cpp.

3963{
3964 for( auto &critter : u.get_visible_creatures( distance ) ) {
3965 if( u.attitude_to( *critter ) == Creature::A_HOSTILE ) {
3966 return critter;
3967 }
3968 }
3969
3970 return nullptr;
3971}
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
std::vector< Creature * > get_visible_creatures(int range) const
Returns all creatures that this player can see and that are in the given range.
@ A_HOSTILE
Definition: creature.h:169

References Creature::A_HOSTILE, Character::attitude_to(), Character::get_visible_creatures(), and u.

Referenced by is_hostile_nearby(), and is_hostile_very_close().

◆ is_in_sunlight()

bool game::is_in_sunlight ( const tripoint p)

Returns true if p is outdoors and it is sunny.

Definition at line 5159 of file game.cpp.

5160{
5161 return weather::is_in_sunlight( m, p, get_weather().weather_id );
5162}
bool is_in_sunlight(const map &m, const tripoint &p, const weather_type_id &weather)
Definition: weather.cpp:1162

References get_weather, weather::is_in_sunlight(), and m.

Referenced by process_artifact().

◆ is_in_viewport()

bool game::is_in_viewport ( const tripoint p,
int  margin = 0 
) const

Definition at line 3596 of file game.cpp.

3597{
3598 const tripoint diff( u.pos() + u.view_offset - p );
3599
3600 return ( std::abs( diff.x ) <= getmaxx( w_terrain ) / 2 - margin ) &&
3601 ( std::abs( diff.y ) <= getmaxy( w_terrain ) / 2 - margin );
3602}

References catacurses::getmaxx(), catacurses::getmaxy(), Character::pos(), u, player::view_offset, w_terrain, tripoint::x, and tripoint::y.

◆ is_sheltered()

bool game::is_sheltered ( const tripoint p)

Returns true if p is indoors, underground, or in a car.

Definition at line 5164 of file game.cpp.

5165{
5166 return weather::is_sheltered( m, p );
5167}
bool is_sheltered(const map &m, const tripoint &p)
Definition: weather.cpp:1153

References weather::is_sheltered(), and m.

◆ is_zones_manager_open()

bool game::is_zones_manager_open ( ) const

Definition at line 6307 of file game.cpp.

6308{
6309 return zones_manager_open;
6310}
bool zones_manager_open
Is Zone manager open or not - changes graphics of some zone tiles.
Definition: game.h:1101

References zones_manager_open.

◆ item_action_menu()

void game::item_action_menu ( )
private

Definition at line 231 of file item_action.cpp.

232{
233 const auto &gen = item_action_generator::generator();
234 const action_map &item_actions = gen.get_item_action_map();
235
236 // HACK: A bit of a hack for now. If more pseudos get implemented, this should be un-hacked
237 std::vector<item *> pseudos;
238 item toolset( "toolset", calendar::turn );
239 if( u.has_active_bionic( bio_tools ) ) {
240 pseudos.push_back( &toolset );
241 }
242 item bio_claws_item( static_cast<std::string>( bio_claws_weapon ), calendar::turn );
243 if( u.has_active_bionic( bio_claws ) ) {
244 pseudos.push_back( &bio_claws_item );
245 }
246
247 item_action_map iactions = gen.map_actions_to_items( u, pseudos );
248 if( iactions.empty() ) {
249 popup( _( "You don't have any items with registered uses" ) );
250 }
251
252 uilist kmenu;
253 kmenu.text = _( "Execute which action?" );
254 kmenu.input_category = "ITEM_ACTIONS";
255 input_context ctxt( "ITEM_ACTIONS" );
256 for( const auto &id : item_actions ) {
257 ctxt.register_action( id.first, id.second.name );
258 kmenu.additional_actions.emplace_back( id.first, id.second.name );
259 }
260 actmenu_cb callback( item_actions );
261 kmenu.callback = &callback;
262 int num = 0;
263
264 const auto assigned_action = [&iactions]( const item_action_id & action ) {
265 return iactions.find( action ) != iactions.end();
266 };
267
268 std::vector<std::tuple<item_action_id, std::string, std::string>> menu_items;
269 // Sorts menu items by action.
270 using Iter = decltype( menu_items )::iterator;
271 const auto sort_menu = []( Iter from, Iter to ) {
272 std::sort( from, to, []( const std::tuple<item_action_id, std::string, std::string> &lhs,
273 const std::tuple<item_action_id, std::string, std::string> &rhs ) {
274 return std::get<1>( lhs ).compare( std::get<1>( rhs ) ) < 0;
275 } );
276 };
277 // Add mapped actions to the menu vector.
278 std::transform( iactions.begin(), iactions.end(), std::back_inserter( menu_items ),
279 []( const std::pair<item_action_id, item *> &elem ) {
280 std::string ss = elem.second->display_name();
281 if( elem.second->ammo_required() ) {
282 ss += string_format( " (%d/%d)", elem.second->ammo_required(), elem.second->ammo_remaining() );
283 }
284
285 const auto method = elem.second->get_use( elem.first );
286 if( method ) {
287 return std::make_tuple( method->get_type(), method->get_name(), ss );
288 } else {
289 return std::make_tuple( errstring, std::string( "NO USE FUNCTION" ), ss );
290 }
291 } );
292 // Sort mapped actions.
293 sort_menu( menu_items.begin(), menu_items.end() );
294 // Add unmapped but binded actions to the menu vector.
295 for( const auto &elem : item_actions ) {
296 if( key_bound_to( ctxt, elem.first ) != '\0' && !assigned_action( elem.first ) ) {
297 menu_items.emplace_back( elem.first, gen.get_action_name( elem.first ), "-" );
298 }
299 }
300 // Sort unmapped actions.
301 auto iter = menu_items.begin();
302 std::advance( iter, iactions.size() );
303 sort_menu( iter, menu_items.end() );
304 // Determine max lengths, to print the menu nicely.
305 std::pair<int, int> max_len;
306 for( const auto &elem : menu_items ) {
307 max_len.first = std::max( max_len.first, utf8_width( std::get<1>( elem ), true ) );
308 max_len.second = std::max( max_len.second, utf8_width( std::get<2>( elem ), true ) );
309 }
310 // Fill the menu.
311 for( const auto &elem : menu_items ) {
312 std::string ss;
313 ss += std::get<1>( elem );
314 ss += std::string( max_len.first - utf8_width( std::get<1>( elem ), true ), ' ' );
315 ss += std::string( 4, ' ' );
316
317 ss += std::get<2>( elem );
318 ss += std::string( max_len.second - utf8_width( std::get<2>( elem ), true ), ' ' );
319
320 const char bind = key_bound_to( ctxt, std::get<0>( elem ) );
321 const bool enabled = assigned_action( std::get<0>( elem ) );
322
323 kmenu.addentry( num, enabled, bind, ss );
324 num++;
325 }
326
327 kmenu.query();
328 if( kmenu.ret < 0 || kmenu.ret >= static_cast<int>( iactions.size() ) ) {
329 return;
330 }
331
332 const item_action_id action = std::get<0>( menu_items[kmenu.ret] );
333 item *it = iactions[action];
334
335 u.invoke_item( it, action );
336
337 u.inv.restack( u );
338 u.inv.unsort();
339}
inventory inv
Definition: character.h:1527
bool invoke_item(item *, const tripoint &pt) override
Asks how to use the item (if it has more than one use_method) and uses it.
Definition: avatar.cpp:1242
void restack(player &p)
Definition: inventory.cpp:398
void unsort()
Definition: inventory.cpp:226
static item_action_generator & generator()
Definition: item_action.h:32
std::string input_category
Definition: ui.h:325
std::vector< std::pair< std::string, translation > > additional_actions
Definition: ui.h:326
static char key_bound_to(const input_context &ctxt, const item_action_id &act)
Definition: item_action.cpp:47
static const bionic_id bio_claws("bio_claws")
static const bionic_id bio_tools("bio_tools")
static const bionic_id bio_claws_weapon("bio_claws_weapon")
std::string item_action_id
Definition: item_action.h:16
std::map< item_action_id, item_action > action_map
Definition: item_action.h:18
std::map< item_action_id, item * > item_action_map
Definition: item_action.h:17

References _, action, uilist::additional_actions, bio_claws, bio_claws_weapon, bio_tools, uilist::callback, item_action_generator::generator(), Character::has_active_bionic(), uilist::input_category, num, popup(), input_context::register_action(), second, uilist::text, iexamine::transform(), calendar::turn, and u.

Referenced by handle_action().

◆ knockback() [1/2]

void game::knockback ( const tripoint s,
const tripoint t,
int  force,
int  stun,
int  dam_mult 
)

Definition at line 4586 of file game.cpp.

4587{
4588 std::vector<tripoint> traj;
4589 traj.clear();
4590 traj = line_to( s, t, 0, 0 );
4591 traj.insert( traj.begin(), s ); // how annoying, line_to() doesn't include the originating point!
4592 traj = continue_line( traj, force );
4593 traj.insert( traj.begin(), t ); // how annoying, continue_line() doesn't either!
4594
4595 knockback( traj, stun, dam_mult );
4596}
std::vector< coords::coord_point< Point, Origin, Scale > > line_to(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:548
std::vector< tripoint > continue_line(const std::vector< tripoint > &line, const int distance)
Definition: line.cpp:408

References continue_line(), knockback(), and line_to().

Referenced by forced_door_closing(), and knockback().

◆ knockback() [2/2]

void game::knockback ( std::vector< tripoint > &  traj,
int  stun,
int  dam_mult 
)

Definition at line 4602 of file game.cpp.

4603{
4604 // TODO: make the force parameter actually do something.
4605 // the header file says higher force causes more damage.
4606 // perhaps that is what it should do?
4607 tripoint tp = traj.front();
4608 if( !critter_at( tp ) ) {
4609 debugmsg( _( "Nothing at (%d,%d,%d) to knockback!" ), tp.x, tp.y, tp.z );
4610 return;
4611 }
4612 std::size_t force_remaining = traj.size();
4613 if( monster *const targ = critter_at<monster>( tp, true ) ) {
4614 if( stun > 0 ) {
4615 targ->add_effect( effect_stunned, 1_turns * stun );
4616 add_msg( _( "%s was stunned!" ), targ->name() );
4617 }
4618 for( size_t i = 1; i < traj.size(); i++ ) {
4619 if( m.impassable( traj[i].xy() ) ) {
4620 targ->setpos( traj[i - 1] );
4621 force_remaining = traj.size() - i;
4622 if( stun != 0 ) {
4623 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4624 add_msg( _( "%s was stunned!" ), targ->name() );
4625 add_msg( _( "%s slammed into an obstacle!" ), targ->name() );
4626 targ->apply_damage( nullptr, bodypart_id( "torso" ), dam_mult * force_remaining );
4627 targ->check_dead_state();
4628 }
4629 m.bash( traj[i], 2 * dam_mult * force_remaining );
4630 break;
4631 } else if( critter_at( traj[i] ) ) {
4632 targ->setpos( traj[i - 1] );
4633 force_remaining = traj.size() - i;
4634 if( stun != 0 ) {
4635 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4636 add_msg( _( "%s was stunned!" ), targ->name() );
4637 }
4638 traj.erase( traj.begin(), traj.begin() + i );
4639 if( critter_at<monster>( traj.front() ) ) {
4640 add_msg( _( "%s collided with something else and sent it flying!" ),
4641 targ->name() );
4642 } else if( npc *const guy = critter_at<npc>( traj.front() ) ) {
4643 if( guy->male ) {
4644 add_msg( _( "%s collided with someone else and sent him flying!" ),
4645 targ->name() );
4646 } else {
4647 add_msg( _( "%s collided with someone else and sent her flying!" ),
4648 targ->name() );
4649 }
4650 } else if( u.pos() == traj.front() ) {
4651 add_msg( m_bad, _( "%s collided with you and sent you flying!" ), targ->name() );
4652 }
4653 knockback( traj, stun, dam_mult );
4654 break;
4655 }
4656 targ->setpos( traj[i] );
4657 if( m.has_flag( "LIQUID", targ->pos() ) && !targ->can_drown() && !targ->is_dead() ) {
4658 targ->die( nullptr );
4659 if( u.sees( *targ ) ) {
4660 add_msg( _( "The %s drowns!" ), targ->name() );
4661 }
4662 }
4663 if( !m.has_flag( "LIQUID", targ->pos() ) && targ->has_flag( MF_AQUATIC ) &&
4664 !targ->is_dead() ) {
4665 targ->die( nullptr );
4666 if( u.sees( *targ ) ) {
4667 add_msg( _( "The %s flops around and dies!" ), targ->name() );
4668 }
4669 }
4670 }
4671 } else if( npc *const targ = critter_at<npc>( tp ) ) {
4672 if( stun > 0 ) {
4673 targ->add_effect( effect_stunned, 1_turns * stun );
4674 add_msg( _( "%s was stunned!" ), targ->name );
4675 }
4676 for( size_t i = 1; i < traj.size(); i++ ) {
4677 if( m.impassable( traj[i].xy() ) ) { // oops, we hit a wall!
4678 targ->setpos( traj[i - 1] );
4679 force_remaining = traj.size() - i;
4680 if( stun != 0 ) {
4681 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4682 if( targ->has_effect( effect_stunned ) ) {
4683 add_msg( _( "%s was stunned!" ), targ->name );
4684 }
4685
4686 std::array<bodypart_id, 8> bps = {{
4687 bodypart_id( "head" ),
4688 bodypart_id( "arm_l" ), bodypart_id( "arm_r" ),
4689 bodypart_id( "hand_l" ), bodypart_id( "hand_r" ),
4690 bodypart_id( "torso" ),
4691 bodypart_id( "leg_l" ), bodypart_id( "leg_r" )
4692 }
4693 };
4694 for( const bodypart_id &bp : bps ) {
4695 if( one_in( 2 ) ) {
4696 targ->deal_damage( nullptr, bp, damage_instance( DT_BASH, force_remaining * dam_mult ) );
4697 }
4698 }
4699 targ->check_dead_state();
4700 }
4701 m.bash( traj[i], 2 * dam_mult * force_remaining );
4702 break;
4703 } else if( critter_at( traj[i] ) ) {
4704 targ->setpos( traj[i - 1] );
4705 force_remaining = traj.size() - i;
4706 if( stun != 0 ) {
4707 add_msg( _( "%s was stunned!" ), targ->name );
4708 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4709 }
4710 traj.erase( traj.begin(), traj.begin() + i );
4711 const tripoint &traj_front = traj.front();
4712 if( critter_at<monster>( traj_front ) ) {
4713 add_msg( _( "%s collided with something else and sent it flying!" ),
4714 targ->name );
4715 } else if( npc *const guy = critter_at<npc>( traj_front ) ) {
4716 if( guy->male ) {
4717 add_msg( _( "%s collided with someone else and sent him flying!" ),
4718 targ->name );
4719 } else {
4720 add_msg( _( "%s collided with someone else and sent her flying!" ),
4721 targ->name );
4722 }
4723 } else if( u.posx() == traj_front.x && u.posy() == traj_front.y &&
4725 ( u.footwear_factor() == .5 && one_in( 2 ) ) ) ) ) {
4726 add_msg( _( "%s collided with you, and barely dislodges your tentacles!" ), targ->name );
4727 } else if( u.posx() == traj_front.x && u.posy() == traj_front.y ) {
4728 add_msg( m_bad, _( "%s collided with you and sent you flying!" ), targ->name );
4729 }
4730 knockback( traj, stun, dam_mult );
4731 break;
4732 }
4733 targ->setpos( traj[i] );
4734 }
4735 } else if( u.pos() == tp ) {
4736 if( stun > 0 ) {
4737 u.add_effect( effect_stunned, 1_turns * stun );
4738 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4739 "You were stunned for %d turns!",
4740 stun ),
4741 stun );
4742 }
4743 for( size_t i = 1; i < traj.size(); i++ ) {
4744 if( m.impassable( traj[i] ) ) { // oops, we hit a wall!
4745 u.setpos( traj[i - 1] );
4746 force_remaining = traj.size() - i;
4747 if( stun != 0 ) {
4748 if( u.has_effect( effect_stunned ) ) {
4749 add_msg( m_bad, vgettext( "You were stunned AGAIN for %d turn!",
4750 "You were stunned AGAIN for %d turns!",
4751 force_remaining ),
4752 force_remaining );
4753 } else {
4754 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4755 "You were stunned for %d turns!",
4756 force_remaining ),
4757 force_remaining );
4758 }
4759 u.add_effect( effect_stunned, 1_turns * force_remaining );
4760 std::array<bodypart_id, 8> bps = {{
4761 bodypart_id( "head" ),
4762 bodypart_id( "arm_l" ), bodypart_id( "arm_r" ),
4763 bodypart_id( "hand_l" ), bodypart_id( "hand_r" ),
4764 bodypart_id( "torso" ),
4765 bodypart_id( "leg_l" ), bodypart_id( "leg_r" )
4766 }
4767 };
4768 for( const bodypart_id &bp : bps ) {
4769 if( one_in( 2 ) ) {
4770 u.deal_damage( nullptr, bp, damage_instance( DT_BASH, force_remaining * dam_mult ) );
4771 }
4772 }
4774 }
4775 m.bash( traj[i], 2 * dam_mult * force_remaining );
4776 break;
4777 } else if( critter_at( traj[i] ) ) {
4778 u.setpos( traj[i - 1] );
4779 force_remaining = traj.size() - i;
4780 if( stun != 0 ) {
4781 if( u.has_effect( effect_stunned ) ) {
4782 add_msg( m_bad, vgettext( "You were stunned AGAIN for %d turn!",
4783 "You were stunned AGAIN for %d turns!",
4784 force_remaining ),
4785 force_remaining );
4786 } else {
4787 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4788 "You were stunned for %d turns!",
4789 force_remaining ),
4790 force_remaining );
4791 }
4792 u.add_effect( effect_stunned, 1_turns * force_remaining );
4793 }
4794 traj.erase( traj.begin(), traj.begin() + i );
4795 if( critter_at<monster>( traj.front() ) ) {
4796 add_msg( _( "You collided with something and sent it flying!" ) );
4797 } else if( npc *const guy = critter_at<npc>( traj.front() ) ) {
4798 if( guy->male ) {
4799 add_msg( _( "You collided with someone and sent him flying!" ) );
4800 } else {
4801 add_msg( _( "You collided with someone and sent her flying!" ) );
4802 }
4803 }
4804 knockback( traj, stun, dam_mult );
4805 break;
4806 }
4807 if( m.has_flag( "LIQUID", u.pos() ) && force_remaining == 0 ) {
4808 avatar_action::swim( m, u, u.pos() );
4809 } else {
4810 u.setpos( traj[i] );
4811 }
4812 }
4813 }
4814}
double footwear_factor() const
Returns 1 if the player is wearing something on both feet, .5 if on one, and 0 if on neither.
Definition: character.cpp:8949
dealt_damage_instance deal_damage(Creature *source, bodypart_id bp, const damage_instance &d) override
Calls Creature::deal_damage and handles damaged effects (waking up, etc.)
Definition: character.cpp:8473
void add_effect(const effect &eff, bool force=false, bool deferred=false)
Definition: creature.cpp:977
@ DT_BASH
Definition: damage.h:24
static const trait_id trait_LEG_TENT_BRACE("LEG_TENT_BRACE")
static const efftype_id effect_stunned("stunned")
@ MF_AQUATIC
Definition: mtype.h:89
void swim(map &m, avatar &you, const tripoint &p)
Handles swimming by the player.
const char * vgettext(const char *msgid, const char *msgid_plural, size_t n)

References _, Creature::add_effect(), add_msg(), map::bash(), Creature::check_dead_state(), critter_at(), Character::deal_damage(), debugmsg, DT_BASH, effect_stunned, Character::footwear_factor(), Creature::has_effect(), map::has_flag(), Character::has_trait(), map::impassable(), knockback(), m, m_bad, MF_AQUATIC, one_in(), Character::pos(), Character::posx(), Character::posy(), Character::sees(), Character::setpos(), avatar_action::swim(), trait_LEG_TENT_BRACE, u, vgettext(), tripoint::x, tripoint::y, and tripoint::z.

◆ light_level()

unsigned char game::light_level ( int  zlev) const

Returns coarse number-of-squares of visibility at the current light level.

Used by monster and NPC AI.

Definition at line 3929 of file game.cpp.

3930{
3931 const float light = natural_light_level( zlev );
3932 return LIGHT_RANGE( light );
3933}
float natural_light_level(int zlev) const
Definition: game.cpp:3869
#define LIGHT_RANGE(b)
Definition: lightmap.h:41

References light, LIGHT_RANGE, and natural_light_level().

Referenced by calc_driving_offset(), and update_overmap_seen().

◆ list_active_characters()

std::vector< std::string > game::list_active_characters ( )

Returns a list of currently active character saves.

Definition at line 3136 of file game.cpp.

3137{
3138 std::vector<std::string> saves;
3139 for( auto &worldsave : world_generator->active_world->world_saves ) {
3140 saves.push_back( worldsave.player_name() );
3141 }
3142 return saves;
3143}

References world_generator.

Referenced by cleanup_at_end().

◆ list_items()

game::vmenu_ret game::list_items ( const std::vector< map_item_stack > &  item_list)
private

Definition at line 7541 of file game.cpp.

7542{
7543 std::vector<map_item_stack> ground_items = item_list;
7544 int iInfoHeight = 0;
7545 int iMaxRows = 0;
7546 int width = 0;
7547 int max_name_width = 0;
7548
7549 //find max length of item name and resize window width
7550 for( const map_item_stack &cur_item : ground_items ) {
7551 const int item_len = utf8_width( remove_color_tags( cur_item.example->display_name() ) ) + 15;
7552 if( item_len > max_name_width ) {
7553 max_name_width = item_len;
7554 }
7555 }
7556
7557 tripoint active_pos;
7558 map_item_stack *activeItem = nullptr;
7559
7560 catacurses::window w_items;
7561 catacurses::window w_items_border;
7562 catacurses::window w_item_info;
7563
7564 ui_adaptor ui;
7565 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
7566 iInfoHeight = std::min( 25, TERMY / 2 );
7567 iMaxRows = TERMY - iInfoHeight - 2;
7568
7569 width = clamp( max_name_width, 45, TERMX / 3 );
7570
7571 const int offsetX = TERMX - width;
7572
7573 w_items = catacurses::newwin( TERMY - 2 - iInfoHeight,
7574 width - 2, point( offsetX + 1, 1 ) );
7575 w_items_border = catacurses::newwin( TERMY - iInfoHeight,
7576 width, point( offsetX, 0 ) );
7577 w_item_info = catacurses::newwin( iInfoHeight, width,
7578 point( offsetX, TERMY - iInfoHeight ) );
7579
7580 if( activeItem ) {
7581 centerlistview( active_pos, width );
7582 }
7583
7584 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
7585 } );
7586 ui.mark_resize();
7587
7588 // use previously selected sorting method
7589 bool sort_radius = uistate.list_item_sort != 2;
7590 bool addcategory = !sort_radius;
7591
7592 // reload filter/priority settings on the first invocation, if they were active
7593 if( !uistate.list_item_init ) {
7596 }
7599 }
7602 }
7603 uistate.list_item_init = true;
7604 }
7605
7606 //this stores only those items that match our filter
7607 std::vector<map_item_stack> filtered_items =
7608 !sFilter.empty() ? filter_item_stacks( ground_items, sFilter ) : ground_items;
7609 int highPEnd = list_filter_high_priority( filtered_items, list_item_upvote );
7610 int lowPStart = list_filter_low_priority( filtered_items, highPEnd, list_item_downvote );
7611 int iItemNum = ground_items.size();
7612
7613 const tripoint stored_view_offset = u.view_offset;
7614
7616
7617 int iActive = 0; // Item index that we're looking at
7618 bool refilter = true;
7619 int page_num = 0;
7620 int iCatSortNum = 0;
7621 int iScrollPos = 0;
7622 std::map<int, std::string> mSortCategory;
7623
7624 std::string action;
7625 input_context ctxt( "LIST_ITEMS" );
7626 ctxt.register_action( "UP", to_translation( "Move cursor up" ) );
7627 ctxt.register_action( "DOWN", to_translation( "Move cursor down" ) );
7628 ctxt.register_action( "LEFT", to_translation( "Previous item" ) );
7629 ctxt.register_action( "RIGHT", to_translation( "Next item" ) );
7630 ctxt.register_action( "PAGE_DOWN" );
7631 ctxt.register_action( "PAGE_UP" );
7632 ctxt.register_action( "NEXT_TAB" );
7633 ctxt.register_action( "PREV_TAB" );
7634 ctxt.register_action( "HELP_KEYBINDINGS" );
7635 ctxt.register_action( "QUIT" );
7636 ctxt.register_action( "FILTER" );
7637 ctxt.register_action( "RESET_FILTER" );
7638 ctxt.register_action( "EXAMINE" );
7639 ctxt.register_action( "COMPARE" );
7640 ctxt.register_action( "PRIORITY_INCREASE" );
7641 ctxt.register_action( "PRIORITY_DECREASE" );
7642 ctxt.register_action( "SORT" );
7643 ctxt.register_action( "TRAVEL_TO" );
7644
7646
7647 ui.on_redraw( [&]( const ui_adaptor & ) {
7648 reset_item_list_state( w_items_border, iInfoHeight, sort_radius );
7649
7650 if( ground_items.empty() ) {
7651 wnoutrefresh( w_items_border );
7652 mvwprintz( w_items, point( 2, 10 ), c_white, _( "You don't see any items around you!" ) );
7653 } else {
7654 int iStartPos = 0;
7655 werase( w_items );
7656 calcStartPos( iStartPos, iActive, iMaxRows, iItemNum );
7657 int iNum = 0;
7658 bool high = false;
7659 bool low = false;
7660 int index = 0;
7661 int iCatSortOffset = 0;
7662
7663 for( int i = 0; i < iStartPos; i++ ) {
7664 if( !mSortCategory[i].empty() ) {
7665 iNum++;
7666 }
7667 }
7668 for( auto iter = filtered_items.begin(); iter != filtered_items.end(); ++index ) {
7669 if( highPEnd > 0 && index < highPEnd + iCatSortOffset ) {
7670 high = true;
7671 low = false;
7672 } else if( index >= lowPStart + iCatSortOffset ) {
7673 high = false;
7674 low = true;
7675 } else {
7676 high = false;
7677 low = false;
7678 }
7679
7680 if( iNum >= iStartPos && iNum < iStartPos + ( iMaxRows > iItemNum ? iItemNum : iMaxRows ) ) {
7681 int iThisPage = 0;
7682 if( !mSortCategory[iNum].empty() ) {
7683 iCatSortOffset++;
7684 mvwprintz( w_items, point( 1, iNum - iStartPos ), c_magenta, mSortCategory[iNum] );
7685 } else {
7686 if( iNum == iActive ) {
7687 iThisPage = page_num;
7688 }
7689 std::string sText;
7690 if( iter->vIG.size() > 1 ) {
7691 sText += string_format( "[%d/%d] (%d) ", iThisPage + 1, iter->vIG.size(), iter->totalcount );
7692 }
7693 sText += iter->example->tname();
7694 if( iter->vIG[iThisPage].count > 1 ) {
7695 sText += string_format( "[%d]", iter->vIG[iThisPage].count );
7696 }
7697
7698 nc_color col = c_light_green;
7699 if( iNum != iActive ) {
7700 if( high ) {
7701 col = c_yellow;
7702 } else if( low ) {
7703 col = c_red;
7704 } else {
7705 col = iter->example->color_in_inventory();
7706 }
7707 }
7708 trim_and_print( w_items, point( 1, iNum - iStartPos ), width - 9, col, sText );
7709 const int numw = iItemNum > 9 ? 2 : 1;
7710 const int x = iter->vIG[iThisPage].pos.x;
7711 const int y = iter->vIG[iThisPage].pos.y;
7712 mvwprintz( w_items, point( width - 6 - numw, iNum - iStartPos ),
7713 iNum == iActive ? c_light_green : c_light_gray,
7714 "%*d %s", numw, rl_dist( point_zero, point( x, y ) ),
7716 ++iter;
7717 }
7718 } else {
7719 ++iter;
7720 }
7721 iNum++;
7722 }
7723 iNum = 0;
7724 for( int i = 0; i < iActive; i++ ) {
7725 if( !mSortCategory[i].empty() ) {
7726 iNum++;
7727 }
7728 }
7729 mvwprintz( w_items_border, point( ( width - 9 ) / 2 + ( iItemNum > 9 ? 0 : 1 ), 0 ),
7730 c_light_green, " %*d", iItemNum > 9 ? 2 : 1, iItemNum > 0 ? iActive - iNum + 1 : 0 );
7731 wprintz( w_items_border, c_white, " / %*d ", iItemNum > 9 ? 2 : 1, iItemNum - iCatSortNum );
7732 werase( w_item_info );
7733
7734 if( iItemNum > 0 && activeItem ) {
7735 std::vector<iteminfo> vThisItem;
7736 std::vector<iteminfo> vDummy;
7737 activeItem->example->info( true, vThisItem );
7738
7739 item_info_data dummy( "", "", vThisItem, vDummy, iScrollPos );
7740 dummy.without_getch = true;
7741 dummy.without_border = true;
7742
7743 draw_item_info( w_item_info, dummy );
7744 }
7745 draw_scrollbar( w_items_border, iActive, iMaxRows, iItemNum, point_south );
7746 wnoutrefresh( w_items_border );
7747 }
7748
7749 const bool bDrawLeft = ground_items.empty() || filtered_items.empty() || !activeItem || filter_type;
7750 draw_custom_border( w_item_info, bDrawLeft, true, true, true, LINE_XXXO, LINE_XOXX, true, true );
7751
7752 if( iItemNum > 0 && activeItem ) {
7753 // print info window title: < item name >
7754 mvwprintw( w_item_info, point( 2, 0 ), "< " );
7755 trim_and_print( w_item_info, point( 4, 0 ), width - 8, activeItem->example->color_in_inventory(),
7756 activeItem->example->display_name() );
7757 wprintw( w_item_info, " >" );
7758 }
7759
7760 wnoutrefresh( w_items );
7761 wnoutrefresh( w_item_info );
7762
7763 if( filter_type ) {
7764 draw_item_filter_rules( w_item_info, 0, iInfoHeight - 1, filter_type.value() );
7765 }
7766 } );
7767
7768 cata::optional<tripoint> trail_start;
7769 cata::optional<tripoint> trail_end;
7770 bool trail_end_x = false;
7771 shared_ptr_fast<draw_callback_t> trail_cb = create_trail_callback( trail_start, trail_end,
7772 trail_end_x );
7773 add_draw_callback( trail_cb );
7774
7775 do {
7776 if( action == "COMPARE" && activeItem ) {
7777 game_menus::inv::compare( u, active_pos );
7778 } else if( action == "FILTER" ) {
7779 filter_type = item_filter_type::FILTER;
7780 ui.invalidate_ui();
7782 .title( _( "Filter:" ) )
7783 .width( 55 )
7784 .description( _( "UP: history, CTRL-U: clear line, ESC: abort, ENTER: save" ) )
7785 .identifier( "item_filter" )
7786 .max_length( 256 )
7787 .edit( sFilter );
7788 refilter = true;
7789 addcategory = !sort_radius;
7791 filter_type = cata::nullopt;
7792 } else if( action == "RESET_FILTER" ) {
7793 sFilter.clear();
7794 filtered_items = ground_items;
7795 refilter = true;
7797 addcategory = !sort_radius;
7798 } else if( action == "EXAMINE" && !filtered_items.empty() && activeItem ) {
7799 std::vector<iteminfo> vThisItem;
7800 std::vector<iteminfo> vDummy;
7801 activeItem->example->info( true, vThisItem );
7802
7803 item_info_data info_data( activeItem->example->tname(), activeItem->example->type_name(), vThisItem,
7804 vDummy );
7805 info_data.handle_scrolling = true;
7806
7808 return catacurses::newwin( TERMY, width - 5, point_zero );
7809 }, info_data );
7810 } else if( action == "PRIORITY_INCREASE" ) {
7811 filter_type = item_filter_type::HIGH_PRIORITY;
7812 ui.invalidate_ui();
7814 .title( _( "High Priority:" ) )
7815 .width( 55 )
7817 .description( _( "UP: history, CTRL-U clear line, ESC: abort, ENTER: save" ) )
7818 .identifier( "list_item_priority" )
7819 .max_length( 256 )
7820 .query_string();
7821 refilter = true;
7822 addcategory = !sort_radius;
7824 filter_type = cata::nullopt;
7825 } else if( action == "PRIORITY_DECREASE" ) {
7826 filter_type = item_filter_type::LOW_PRIORITY;
7827 ui.invalidate_ui();
7829 .title( _( "Low Priority:" ) )
7830 .width( 55 )
7832 .description( _( "UP: history, CTRL-U clear line, ESC: abort, ENTER: save" ) )
7833 .identifier( "list_item_downvote" )
7834 .max_length( 256 )
7835 .query_string();
7836 refilter = true;
7837 addcategory = !sort_radius;
7839 filter_type = cata::nullopt;
7840 } else if( action == "SORT" ) {
7841 if( sort_radius ) {
7842 sort_radius = false;
7843 addcategory = true;
7844 uistate.list_item_sort = 2; // list is sorted by category
7845 } else {
7846 sort_radius = true;
7847 uistate.list_item_sort = 1; // list is sorted by distance
7848 }
7849 highPEnd = -1;
7850 lowPStart = -1;
7851 iCatSortNum = 0;
7852
7853 mSortCategory.clear();
7854 refilter = true;
7855 } else if( action == "TRAVEL_TO" && activeItem ) {
7856 if( !u.sees( u.pos() + active_pos ) ) {
7857 add_msg( _( "You can't see that destination." ) );
7858 }
7859 auto route = m.route( u.pos(), u.pos() + active_pos, u.get_pathfinding_settings(),
7860 u.get_path_avoid() );
7861 if( route.size() > 1 ) {
7862 route.pop_back();
7863 u.set_destination( route );
7864 break;
7865 } else {
7866 add_msg( m_info, _( "You can't travel there." ) );
7867 }
7868 }
7869 if( uistate.list_item_sort == 1 ) {
7870 ground_items = item_list;
7871 } else if( uistate.list_item_sort == 2 ) {
7872 std::sort( ground_items.begin(), ground_items.end(), map_item_stack::map_item_stack_sort );
7873 }
7874
7875 if( refilter ) {
7876 refilter = false;
7877 filtered_items = filter_item_stacks( ground_items, sFilter );
7878 highPEnd = list_filter_high_priority( filtered_items, list_item_upvote );
7879 lowPStart = list_filter_low_priority( filtered_items, highPEnd, list_item_downvote );
7880 iActive = 0;
7881 page_num = 0;
7882 iItemNum = filtered_items.size();
7883 }
7884
7885 if( addcategory ) {
7886 addcategory = false;
7887 iCatSortNum = 0;
7888 mSortCategory.clear();
7889 if( highPEnd > 0 ) {
7890 mSortCategory[0] = _( "HIGH PRIORITY" );
7891 iCatSortNum++;
7892 }
7893 std::string last_cat_name;
7894 for( int i = std::max( 0, highPEnd );
7895 i < std::min( lowPStart, static_cast<int>( filtered_items.size() ) ); i++ ) {
7896 const std::string &cat_name = filtered_items[i].example->get_category().name();
7897 if( cat_name != last_cat_name ) {
7898 mSortCategory[i + iCatSortNum++] = cat_name;
7899 last_cat_name = cat_name;
7900 }
7901 }
7902 if( lowPStart < static_cast<int>( filtered_items.size() ) ) {
7903 mSortCategory[lowPStart + iCatSortNum++] = _( "LOW PRIORITY" );
7904 }
7905 if( !mSortCategory[0].empty() ) {
7906 iActive++;
7907 }
7908 iItemNum = static_cast<int>( filtered_items.size() ) + iCatSortNum;
7909 }
7910
7911 if( action == "UP" ) {
7912 do {
7913 iActive--;
7914
7915 } while( !mSortCategory[iActive].empty() );
7916 iScrollPos = 0;
7917 page_num = 0;
7918 if( iActive < 0 ) {
7919 iActive = iItemNum - 1;
7920 }
7921 } else if( action == "DOWN" ) {
7922 do {
7923 iActive++;
7924
7925 } while( !mSortCategory[iActive].empty() );
7926 iScrollPos = 0;
7927 page_num = 0;
7928 if( iActive >= iItemNum ) {
7929 iActive = mSortCategory[0].empty() ? 0 : 1;
7930 }
7931 } else if( action == "RIGHT" ) {
7932 if( !filtered_items.empty() && activeItem ) {
7933 if( ++page_num >= static_cast<int>( activeItem->vIG.size() ) ) {
7934 page_num = activeItem->vIG.size() - 1;
7935 }
7936 }
7937 } else if( action == "LEFT" ) {
7938 page_num = std::max( 0, page_num - 1 );
7939 } else if( action == "PAGE_UP" ) {
7940 iScrollPos--;
7941 } else if( action == "PAGE_DOWN" ) {
7942 iScrollPos++;
7943 } else if( action == "NEXT_TAB" || action == "PREV_TAB" ) {
7944 u.view_offset = stored_view_offset;
7946 }
7947
7948 active_pos = tripoint_zero;
7949 activeItem = nullptr;
7950
7951 if( mSortCategory[iActive].empty() ) {
7952 auto iter = filtered_items.begin();
7953 for( int iNum = 0; iter != filtered_items.end() && iNum < iActive; iNum++ ) {
7954 if( mSortCategory[iNum].empty() ) {
7955 ++iter;
7956 }
7957 }
7958 if( iter != filtered_items.end() ) {
7959 active_pos = iter->vIG[page_num].pos;
7960 activeItem = &( *iter );
7961 }
7962 }
7963
7964 if( activeItem ) {
7965 centerlistview( active_pos, width );
7966 trail_start = u.pos();
7967 trail_end = u.pos() + active_pos;
7968 // Actually accessed from the terrain overlay callback `trail_cb` in the
7969 // call to `ui_manager::redraw`.
7970 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
7971 trail_end_x = true;
7972 } else {
7973 u.view_offset = stored_view_offset;
7974 trail_start = trail_end = cata::nullopt;
7975 }
7977
7979
7980 action = ctxt.handle_input();
7981 } while( action != "QUIT" );
7982
7983 u.view_offset = stored_view_offset;
7984 return game::vmenu_ret::QUIT;
7985}
constexpr T clamp(const T &val, const T &min, const T &max)
Clamp first argument so that it is no lower than second and no higher than third.
Definition: cata_utility.h:145
std::string list_item_upvote
Definition: game.h:1079
std::string list_item_downvote
Definition: game.h:1080
std::string sFilter
Definition: game.h:1078
void reset_item_list_state(const catacurses::window &window, int height, bool bRadiusSort)
Definition: game.cpp:7428
nc_color color_in_inventory() const
Returns the color of the item depending on usefulness for the player character, e....
Definition: item.cpp:4015
static bool map_item_stack_sort(const map_item_stack &lhs, const map_item_stack &rhs)
std::vector< item_group > vIG
const item * example
string_input_popup & identifier(const std::string &value)
An identifier to be used to store / get the input history.
string_input_popup & text(const std::string &value)
Set / get the text that can be modified by the user.
void edit(std::string &value)
Edit values in place.
string_input_popup & width(int value)
Width (in console cells) of the input field itself.
string_input_popup & description(const std::string &value)
Additional help text, shown below the input box.
string_input_popup & title(const std::string &value)
The title: short string before the actual input field.
std::string list_item_priority
Definition: uistate.h:120
int list_item_sort
Definition: uistate.h:117
bool list_item_downvote_active
Definition: uistate.h:123
bool list_item_init
Definition: uistate.h:125
bool list_item_filter_active
Definition: uistate.h:122
std::string list_item_filter
Definition: uistate.h:118
bool list_item_priority_active
Definition: uistate.h:124
std::string list_item_downvote
Definition: uistate.h:119
direction direction_from(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:540
static shared_ptr_fast< game::draw_callback_t > create_trail_callback(const cata::optional< tripoint > &trail_start, const cata::optional< tripoint > &trail_end, const bool &trail_end_x)
Definition: game.cpp:3449
uistatedata uistate
Definition: game.cpp:272
static void centerlistview(const tripoint &active_item_position, int ui_width)
Definition: game.cpp:7273
std::string direction_name_short(const direction dir)
Definition: line.cpp:533
int list_filter_high_priority(std::vector< map_item_stack > &stack, const std::string &priorities)
std::vector< map_item_stack > filter_item_stacks(const std::vector< map_item_stack > &stack, const std::string &filter)
int list_filter_low_priority(std::vector< map_item_stack > &stack, const int start, const std::string &priorities)
void mvwprintw(const window &win, const point &p, const std::string &text)
void wprintw(const window &win, const std::string &text)
void calcStartPos(int &iStartPos, const int iCurrentLine, const int iContentHeight, const int iNumEntries)
Definition: output.cpp:1507
void draw_item_filter_rules(const catacurses::window &win, int starty, int height, item_filter_type type)
Write some tips (such as precede items with - to exclude them) onto the window.
Definition: output.cpp:810
void draw_scrollbar(const catacurses::window &window, const int iCurrentLine, const int iContentHeight, const int iNumLines, const point &offset, nc_color bar_color, const bool bDoNotScrollToEnd)
Draw a scrollbar (Legacy function, use class scrollbar instead!)
Definition: output.cpp:1314
std::string remove_color_tags(const std::string &s)
Removes the color tags from the input string.
Definition: output.cpp:145
void draw_custom_border(const catacurses::window &w, const catacurses::chtype ls, const catacurses::chtype rs, const catacurses::chtype ts, const catacurses::chtype bs, const catacurses::chtype tl, const catacurses::chtype tr, const catacurses::chtype bl, const catacurses::chtype br, const nc_color FG, const point &pos, int height, int width)
Definition: output.cpp:524
void trim_and_print(const catacurses::window &w, const point &begin, const int width, const nc_color &base_color, const std::string &text, const report_color_error color_error)
Prints a single line of text.
Definition: output.cpp:214
#define LINE_XOXX
Definition: output.h:47
#define LINE_XXXO
Definition: output.h:45

References _, action, add_draw_callback(), add_msg(), c_light_gray, c_light_green, c_magenta, c_red, c_white, c_yellow, calcStartPos(), centerlistview(), CHANGE_TAB, clamp(), item::color_in_inventory(), game_menus::inv::compare(), create_trail_callback(), string_input_popup::description(), direction_from(), direction_name_short(), item::display_name(), draw_custom_border(), draw_item_filter_rules(), draw_item_info(), draw_scrollbar(), string_input_popup::edit(), map_item_stack::example, FILTER, filter_item_stacks(), Character::get_path_avoid(), Character::get_pathfinding_settings(), input_context::handle_input(), item_info_data::handle_scrolling, high, HIGH_PRIORITY, string_input_popup::identifier(), item::info(), invalidate_main_ui_adaptor(), LINE_XOXX, LINE_XXXO, list_filter_high_priority(), list_filter_low_priority(), list_item_downvote, uistatedata::list_item_downvote, uistatedata::list_item_downvote_active, uistatedata::list_item_filter, uistatedata::list_item_filter_active, uistatedata::list_item_init, uistatedata::list_item_priority, uistatedata::list_item_priority_active, uistatedata::list_item_sort, list_item_upvote, LOW_PRIORITY, m, m_info, map_item_stack::map_item_stack_sort(), string_input_popup::max_length(), catacurses::mvwprintw(), mvwprintz(), catacurses::newwin(), cata::nullopt, point_south, point_zero, Character::pos(), string_input_popup::query_string(), QUIT, ui_manager::redraw(), input_context::register_action(), remove_color_tags(), reset_item_list_state(), rl_dist(), map::route(), Character::sees(), Character::set_destination(), sFilter, string_format(), TERMX, TERMY, string_input_popup::text(), string_input_popup::title(), item::tname(), to_translation(), trim_and_print(), tripoint_zero, item::type_name(), u, uistate, utf8_width(), cata::optional< T >::value(), player::view_offset, map_item_stack::vIG, catacurses::werase(), string_input_popup::width(), item_info_data::without_border, item_info_data::without_getch, catacurses::wnoutrefresh(), catacurses::wprintw(), and wprintz().

Referenced by list_items_monsters().

◆ list_items_monsters()

void game::list_items_monsters ( )
private

Definition at line 7496 of file game.cpp.

7497{
7498 std::vector<Creature *> mons = u.get_visible_creatures( current_daylight_level( calendar::turn ) );
7499 // whole reality bubble
7500 const std::vector<map_item_stack> items = find_nearby_items( 60 );
7501
7502 if( mons.empty() && items.empty() ) {
7503 add_msg( m_info, _( "You don't see any items or monsters around you!" ) );
7504 return;
7505 }
7506
7507 std::sort( mons.begin(), mons.end(), [&]( const Creature * lhs, const Creature * rhs ) {
7508 const auto att_lhs = lhs->attitude_to( u );
7509 const auto att_rhs = rhs->attitude_to( u );
7510
7511 return att_lhs < att_rhs || ( att_lhs == att_rhs
7512 && rl_dist( u.pos(), lhs->pos() ) < rl_dist( u.pos(), rhs->pos() ) );
7513 } );
7514
7515 // If the current list is empty, switch to the non-empty list
7517 if( items.empty() ) {
7518 uistate.vmenu_show_items = false;
7519 }
7520 } else if( mons.empty() ) {
7522 }
7523
7526 while( true ) {
7527 ret = uistate.vmenu_show_items ? list_items( items ) : list_monsters( mons );
7530 } else {
7531 break;
7532 }
7533 }
7534
7535 if( ret == game::vmenu_ret::FIRE ) {
7537 }
7539}
double current_daylight_level(const time_point &p)
Returns the current seasonally-adjusted maximum daylight level.
Definition: calendar.cpp:171
game::vmenu_ret list_monsters(const std::vector< Creature * > &monster_list)
Definition: game.cpp:7987
game::vmenu_ret list_items(const std::vector< map_item_stack > &item_list)
Definition: game.cpp:7541
vmenu_ret
Definition: game.h:805
std::vector< map_item_stack > find_nearby_items(int iRadius)
Definition: game.cpp:7202
void temp_exit_fullscreen()
Definition: game.cpp:538
void reenter_fullscreen()
Definition: game.cpp:548
bool vmenu_show_items
Definition: uistate.h:121

References _, add_msg(), CHANGE_TAB, current_daylight_level(), find_nearby_items(), FIRE, avatar_action::fire_wielded_weapon(), Character::get_visible_creatures(), list_items(), list_monsters(), m_info, reenter_fullscreen(), cata::hash64_detail::ret, temp_exit_fullscreen(), calendar::turn, u, uistate, and uistatedata::vmenu_show_items.

Referenced by handle_action(), and look_around().

◆ list_missions()

void game::list_missions ( )

Definition at line 22 of file mission_ui.cpp.

23{
24 catacurses::window w_missions;
25
26 enum class tab_mode : int {
27 TAB_ACTIVE = 0,
28 TAB_COMPLETED,
29 TAB_FAILED,
30 NUM_TABS,
31 FIRST_TAB = 0,
32 LAST_TAB = NUM_TABS - 1
33 };
34 tab_mode tab = tab_mode::FIRST_TAB;
35 size_t selection = 0;
36 int entries_per_page = 0;
37 input_context ctxt( "MISSIONS" );
38 ctxt.register_cardinal();
39 ctxt.register_action( "CONFIRM" );
40 ctxt.register_action( "QUIT" );
41 ctxt.register_action( "HELP_KEYBINDINGS" );
42
44 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
46
47 // content ranges from y=3 to FULL_SCREEN_HEIGHT - 2
48 entries_per_page = FULL_SCREEN_HEIGHT - 4;
49
50 ui.position_from_window( w_missions );
51 } );
52 ui.mark_resize();
53
54 std::vector<mission *> umissions;
55
56 ui.on_redraw( [&]( const ui_adaptor & ) {
57 werase( w_missions );
58 // entries_per_page * page number
59 const int top_of_page = entries_per_page * ( selection / entries_per_page );
60 const int bottom_of_page =
61 std::min( top_of_page + entries_per_page - 1, static_cast<int>( umissions.size() ) - 1 );
62
63 for( int i = 3; i < FULL_SCREEN_HEIGHT - 1; i++ ) {
64 mvwputch( w_missions, point( 30, i ), BORDER_COLOR, LINE_XOXO );
65 }
66
67 const std::vector<std::pair<tab_mode, std::string>> tabs = {
68 { tab_mode::TAB_ACTIVE, _( "ACTIVE MISSIONS" ) },
69 { tab_mode::TAB_COMPLETED, _( "COMPLETED MISSIONS" ) },
70 { tab_mode::TAB_FAILED, _( "FAILED MISSIONS" ) },
71 };
72 draw_tabs( w_missions, tabs, tab );
73 draw_border_below_tabs( w_missions );
74
75 mvwputch( w_missions, point( 30, 2 ), BORDER_COLOR,
76 tab == tab_mode::TAB_COMPLETED ? ' ' : LINE_OXXX ); // ^|^
77 mvwputch( w_missions, point( 30, FULL_SCREEN_HEIGHT - 1 ), BORDER_COLOR, LINE_XXOX ); // _|_
78
79 draw_scrollbar( w_missions, selection, entries_per_page, umissions.size(), point( 0, 3 ) );
80
81 for( int i = top_of_page; i <= bottom_of_page; i++ ) {
82 const auto miss = umissions[i];
83 const nc_color col = u.get_active_mission() == miss ? c_light_green : c_white;
84 const int y = i - top_of_page + 3;
85 trim_and_print( w_missions, point( 1, y ), 28,
86 static_cast<int>( selection ) == i ? hilite( col ) : col,
87 miss->name() );
88 }
89
90 if( selection < umissions.size() ) {
91 const auto miss = umissions[selection];
92 const nc_color col = u.get_active_mission() == miss ? c_light_green : c_white;
93 std::string for_npc;
94 if( miss->get_npc_id().is_valid() ) {
95 npc *guy = g->find_npc( miss->get_npc_id() );
96 if( guy ) {
97 for_npc = string_format( _( " for %s" ), guy->disp_name() );
98 }
99 }
100
101 int y = 3;
102 y += fold_and_print( w_missions, point( 31, y ), getmaxx( w_missions ) - 33, col,
103 miss->name() + for_npc );
104
105 auto format_tokenized_description = []( const std::string & description,
106 const std::vector<std::pair<int, itype_id>> &rewards ) {
107 std::string formatted_description = description;
108 for( const auto &reward : rewards ) {
109 std::string token = "<reward_count:" + reward.second.str() + ">";
110 formatted_description = replace_all( formatted_description, token,
111 string_format( "%d", reward.first ) );
112 }
113 return formatted_description;
114 };
115
116 y++;
117 if( !miss->get_description().empty() ) {
118 y += fold_and_print( w_missions, point( 31, y ), getmaxx( w_missions ) - 33, c_white,
119 format_tokenized_description( miss->get_description(), miss->get_likely_rewards() ) );
120 }
121 if( miss->has_deadline() ) {
122 const time_point deadline = miss->get_deadline();
123 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Deadline: %s" ), to_string( deadline ) );
124
125 if( tab != tab_mode::TAB_COMPLETED ) {
126 // There's no point in displaying this for a completed mission.
127 // @ TODO: But displaying when you completed it would be useful.
128 const time_duration remaining = deadline - calendar::turn;
129 std::string remaining_time;
130
131 if( remaining <= 0_turns ) {
132 remaining_time = _( "None!" );
133 } else if( u.has_watch() ) {
134 remaining_time = to_string( remaining );
135 } else {
136 remaining_time = to_string_approx( remaining );
137 }
138
139 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Time remaining: %s" ), remaining_time );
140 }
141 }
142 if( miss->has_target() ) {
144 // TODO: target does not contain a z-component, targets are assumed to be on z=0
145 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Target: %s You: %s" ),
146 miss->get_target().to_string(), pos.to_string() );
147 }
148 } else {
149 static const std::map< tab_mode, std::string > nope = {
150 { tab_mode::TAB_ACTIVE, translate_marker( "You have no active missions!" ) },
151 { tab_mode::TAB_COMPLETED, translate_marker( "You haven't completed any missions!" ) },
152 { tab_mode::TAB_FAILED, translate_marker( "You haven't failed any missions!" ) }
153 };
154 mvwprintz( w_missions, point( 31, 4 ), c_light_red, _( nope.at( tab ) ) );
155 }
156
157 wnoutrefresh( w_missions );
158 } );
159
160 while( true ) {
161 umissions.clear();
162 if( tab < tab_mode::FIRST_TAB || tab >= tab_mode::NUM_TABS ) {
163 debugmsg( "The sanity check failed because tab=%d", static_cast<int>( tab ) );
164 tab = tab_mode::FIRST_TAB;
165 }
166 switch( tab ) {
168 umissions = u.get_active_missions();
169 break;
170 case tab_mode::TAB_COMPLETED:
171 umissions = u.get_completed_missions();
172 break;
173 case tab_mode::TAB_FAILED:
174 umissions = u.get_failed_missions();
175 break;
176 default:
177 break;
178 }
179 if( ( !umissions.empty() && selection >= umissions.size() ) ||
180 ( umissions.empty() && selection != 0 ) ) {
181 debugmsg( "Sanity check failed: selection=%d, size=%d", static_cast<int>( selection ),
182 static_cast<int>( umissions.size() ) );
183 selection = 0;
184 }
186 const std::string action = ctxt.handle_input();
187 if( action == "RIGHT" ) {
188 tab = static_cast<tab_mode>( static_cast<int>( tab ) + 1 );
189 if( tab >= tab_mode::NUM_TABS ) {
190 tab = tab_mode::FIRST_TAB;
191 }
192 selection = 0;
193 } else if( action == "LEFT" ) {
194 tab = static_cast<tab_mode>( static_cast<int>( tab ) - 1 );
195 if( tab < tab_mode::FIRST_TAB ) {
196 tab = tab_mode::LAST_TAB;
197 }
198 selection = 0;
199 } else if( action == "DOWN" ) {
200 selection++;
201 if( selection >= umissions.size() ) {
202 selection = 0;
203 }
204 } else if( action == "UP" ) {
205 if( selection == 0 ) {
206 selection = umissions.empty() ? 0 : umissions.size() - 1;
207 } else {
208 selection--;
209 }
210 } else if( action == "CONFIRM" ) {
211 if( tab == tab_mode::TAB_ACTIVE && selection < umissions.size() ) {
212 u.set_active_mission( *umissions[selection] );
213 }
214 break;
215 } else if( action == "QUIT" ) {
216 break;
217 }
218 }
219}
std::string to_string_approx(const time_duration &dur, const bool verbose)
Returns approximate duration.
Definition: calendar.cpp:361
bool has_watch() const
Returns true if the player or their vehicle has a watch.
Definition: character.cpp:844
void set_active_mission(mission &cur_mission)
Set which mission is active.
Definition: avatar.cpp:206
mission * get_active_mission() const
Returns the mission that is currently active.
Definition: avatar.cpp:185
std::vector< mission * > get_completed_missions() const
Definition: avatar.cpp:175
std::vector< mission * > get_active_missions() const
Definition: avatar.cpp:170
std::vector< mission * > get_failed_missions() const
Definition: avatar.cpp:180
A point in the game time.
Definition: calendar.h:431
nc_color hilite(const nc_color &c)
Definition: color.cpp:509
void draw_tabs(const catacurses::window &w, const std::vector< std::string > &tab_texts, size_t current_tab)
Definition: output.cpp:1274
void draw_border_below_tabs(const catacurses::window &w, nc_color border_color)
Definition: output.cpp:587
int fold_and_print(const catacurses::window &w, const point &begin, int width, const nc_color &base_color, const std::string &text, const char split)
Fold and print text in the given window.
Definition: output.cpp:299
#define LINE_XXOX
Definition: output.h:46
std::string replace_all(std::string input, const std::string &what, const std::string &with)
Replace all occurences of 'what' within 'input' with 'with'.
#define translate_marker(x)
Marks a string literal to be extracted for translation.
Definition: translations.h:30
catacurses::window new_centered_win(int nlines, int ncols)
Definition: ui.cpp:30

References _, action, BORDER_COLOR, c_light_green, c_light_red, c_white, debugmsg, Character::disp_name(), draw_border_below_tabs(), draw_scrollbar(), draw_tabs(), fold_and_print(), FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, g, avatar::get_active_mission(), avatar::get_active_missions(), avatar::get_completed_missions(), avatar::get_failed_missions(), catacurses::getmaxx(), Character::global_omt_location(), input_context::handle_input(), Character::has_watch(), hilite(), LINE_OXXX, LINE_XOXO, LINE_XXOX, mvwprintz(), mvwputch(), new_centered_win(), ui_manager::redraw(), input_context::register_action(), input_context::register_cardinal(), replace_all(), avatar::set_active_mission(), string_format(), anonymous_namespace{bionics_ui.cpp}::TAB_ACTIVE, coords::coord_point< Point, Origin, Scale >::to_string(), to_string(), to_string_approx(), translate_marker, trim_and_print(), calendar::turn, u, catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by handle_action().

◆ list_monsters()

game::vmenu_ret game::list_monsters ( const std::vector< Creature * > &  monster_list)
private

Definition at line 7987 of file game.cpp.

7988{
7989 const int iInfoHeight = 15;
7990 const int width = 45;
7991 int offsetX = 0;
7992 int iMaxRows = 0;
7993
7994 catacurses::window w_monsters;
7995 catacurses::window w_monsters_border;
7996 catacurses::window w_monster_info;
7997 catacurses::window w_monster_info_border;
7998
7999 Creature *cCurMon = nullptr;
8000 tripoint iActivePos;
8001
8002 bool hide_ui = false;
8003
8004 ui_adaptor ui;
8005 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
8006 if( hide_ui ) {
8007 ui.position( point_zero, point_zero );
8008 } else {
8009 offsetX = TERMX - width;
8010 iMaxRows = TERMY - iInfoHeight - 1;
8011
8012 w_monsters = catacurses::newwin( iMaxRows, width - 2, point( offsetX + 1,
8013 1 ) );
8014 w_monsters_border = catacurses::newwin( iMaxRows + 1, width, point( offsetX,
8015 0 ) );
8016 w_monster_info = catacurses::newwin( iInfoHeight - 2, width - 2,
8017 point( offsetX + 1, TERMY - iInfoHeight + 1 ) );
8018 w_monster_info_border = catacurses::newwin( iInfoHeight, width, point( offsetX,
8019 TERMY - iInfoHeight ) );
8020
8021 if( cCurMon ) {
8022 centerlistview( iActivePos, width );
8023 }
8024
8025 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
8026 }
8027 } );
8028 ui.mark_resize();
8029
8030 const int max_gun_range = u.weapon.gun_range( &u );
8031
8032 const tripoint stored_view_offset = u.view_offset;
8034
8035 int iActive = 0; // monster index that we're looking at
8036
8037 std::string action;
8038 input_context ctxt( "LIST_MONSTERS" );
8039 ctxt.register_action( "UP", to_translation( "Move cursor up" ) );
8040 ctxt.register_action( "DOWN", to_translation( "Move cursor down" ) );
8041 ctxt.register_action( "NEXT_TAB" );
8042 ctxt.register_action( "PREV_TAB" );
8043 ctxt.register_action( "SAFEMODE_BLACKLIST_ADD" );
8044 ctxt.register_action( "SAFEMODE_BLACKLIST_REMOVE" );
8045 ctxt.register_action( "QUIT" );
8046 if( bVMonsterLookFire ) {
8047 ctxt.register_action( "look" );
8048 ctxt.register_action( "fire" );
8049 }
8050 ctxt.register_action( "HELP_KEYBINDINGS" );
8051
8052 // first integer is the row the attitude category string is printed in the menu
8053 std::map<int, Creature::Attitude> mSortCategory;
8054
8055 for( int i = 0, last_attitude = -1; i < static_cast<int>( monster_list.size() ); i++ ) {
8056 const auto attitude = monster_list[i]->attitude_to( u );
8057 if( attitude != last_attitude ) {
8058 mSortCategory[i + mSortCategory.size()] = attitude;
8059 last_attitude = attitude;
8060 }
8061 }
8062
8063 ui.on_redraw( [&]( const ui_adaptor & ) {
8064 if( !hide_ui ) {
8065 draw_custom_border( w_monsters_border, true, true, true, true, true, true, LINE_XOXO, LINE_XOXO );
8066 draw_custom_border( w_monster_info_border, true, true, true, true, LINE_XXXO, LINE_XOXX, true,
8067 true );
8068
8069 mvwprintz( w_monsters_border, point( 2, 0 ), c_light_green, "<Tab> " );
8070 wprintz( w_monsters_border, c_white, _( "Monsters" ) );
8071
8072 if( monster_list.empty() ) {
8073 werase( w_monsters );
8074 mvwprintz( w_monsters, point( 2, iMaxRows / 3 ), c_white,
8075 _( "You don't see any monsters around you!" ) );
8076 } else {
8077 werase( w_monsters );
8078
8079 const int iNumMonster = monster_list.size();
8080 const int iMenuSize = monster_list.size() + mSortCategory.size();
8081
8082 const int numw = iNumMonster > 999 ? 4 :
8083 iNumMonster > 99 ? 3 :
8084 iNumMonster > 9 ? 2 : 1;
8085
8086 // given the currently selected monster iActive. get the selected row
8087 int iSelPos = iActive;
8088 for( auto &ia : mSortCategory ) {
8089 int index = ia.first;
8090 if( index <= iSelPos ) {
8091 ++iSelPos;
8092 } else {
8093 break;
8094 }
8095 }
8096 int iStartPos = 0;
8097 // use selected row get the start row
8098 calcStartPos( iStartPos, iSelPos, iMaxRows - 1, iMenuSize );
8099
8100 // get first visible monster and category
8101 int iCurMon = iStartPos;
8102 auto CatSortIter = mSortCategory.cbegin();
8103 while( CatSortIter != mSortCategory.cend() && CatSortIter->first < iStartPos ) {
8104 ++CatSortIter;
8105 --iCurMon;
8106 }
8107
8108 const auto endY = std::min<int>( iMaxRows - 1, iMenuSize );
8109 for( int y = 0; y < endY; ++y ) {
8110 if( CatSortIter != mSortCategory.cend() ) {
8111 const int iCurPos = iStartPos + y;
8112 const int iCatPos = CatSortIter->first;
8113 if( iCurPos == iCatPos ) {
8114 const std::string cat_name = Creature::get_attitude_ui_data(
8115 CatSortIter->second ).first.translated();
8116 mvwprintz( w_monsters, point( 1, y ), c_magenta, cat_name );
8117 ++CatSortIter;
8118 continue;
8119 }
8120 }
8121 // select current monster
8122 const auto critter = monster_list[iCurMon];
8123 const bool selected = iCurMon == iActive;
8124 ++iCurMon;
8125 if( critter->sees( g->u ) ) {
8126 mvwprintz( w_monsters, point( 0, y ), c_yellow, "!" );
8127 }
8128 bool is_npc = false;
8129 const monster *m = dynamic_cast<monster *>( critter );
8130 const npc *p = dynamic_cast<npc *>( critter );
8131 nc_color name_color = critter->basic_symbol_color();
8132
8133 if( selected ) {
8134 name_color = hilite( name_color );
8135 }
8136
8137 if( m != nullptr ) {
8138 trim_and_print( w_monsters, point( 1, y ), width - 26, name_color, m->name() );
8139 } else {
8140 trim_and_print( w_monsters, point( 1, y ), width - 26, name_color, critter->disp_name() );
8141 is_npc = true;
8142 }
8143
8144 if( selected && !get_safemode().empty() ) {
8145 const std::string monName = is_npc ? get_safemode().npc_type_name() : m->name();
8146
8147 std::string sSafemode;
8148 if( get_safemode().has_rule( monName, Creature::A_ANY ) ) {
8149 sSafemode = _( "<R>emove from safemode Blacklist" );
8150 } else {
8151 sSafemode = _( "<A>dd to safemode Blacklist" );
8152 }
8153
8154 shortcut_print( w_monsters, point( 2, getmaxy( w_monsters ) - 1 ),
8155 c_white, c_light_green, sSafemode );
8156 }
8157
8159 std::string sText;
8160
8161 if( m != nullptr ) {
8162 m->get_HP_Bar( color, sText );
8163 } else {
8164 std::tie( sText, color ) =
8165 ::get_hp_bar( critter->get_hp(), critter->get_hp_max(), false );
8166 }
8167 mvwprintz( w_monsters, point( width - 25, y ), color, sText );
8168
8169 if( m != nullptr ) {
8170 const auto att = m->get_attitude();
8171 sText = att.first;
8172 color = att.second;
8173 } else if( p != nullptr ) {
8174 sText = npc_attitude_name( p->get_attitude() );
8175 color = p->symbol_color();
8176 }
8177 mvwprintz( w_monsters, point( width - 19, y ), color, sText );
8178
8179 const int mon_dist = rl_dist( u.pos(), critter->pos() );
8180 const int numd = mon_dist > 999 ? 4 :
8181 mon_dist > 99 ? 3 :
8182 mon_dist > 9 ? 2 : 1;
8183
8184 trim_and_print( w_monsters, point( width - ( 8 + numd ), y ), 6 + numd,
8185 selected ? c_light_green : c_light_gray,
8186 "%*d %s",
8187 numd, mon_dist,
8188 direction_name_short( direction_from( u.pos(), critter->pos() ) ) );
8189 }
8190
8191 mvwprintz( w_monsters_border, point( ( width / 2 ) - numw - 2, 0 ), c_light_green, " %*d", numw,
8192 iActive + 1 );
8193 wprintz( w_monsters_border, c_white, " / %*d ", numw, static_cast<int>( monster_list.size() ) );
8194
8195 werase( w_monster_info );
8196 if( cCurMon ) {
8197 cCurMon->print_info( w_monster_info, 1, iInfoHeight - 3, 1 );
8198 }
8199
8200 draw_custom_border( w_monster_info_border, true, true, true, true, LINE_XXXO, LINE_XOXX, true,
8201 true );
8202
8203 if( bVMonsterLookFire ) {
8204 mvwprintw( w_monster_info_border, point_east, "< " );
8205 wprintz( w_monster_info_border, c_light_green, ctxt.press_x( "look" ) );
8206 wprintz( w_monster_info_border, c_light_gray, " %s", _( "to look around" ) );
8207
8208 if( cCurMon && rl_dist( u.pos(), cCurMon->pos() ) <= max_gun_range ) {
8209 wprintw( w_monster_info_border, " " );
8210 wprintz( w_monster_info_border, c_light_green, ctxt.press_x( "fire" ) );
8211 wprintz( w_monster_info_border, c_light_gray, " %s", _( "to shoot" ) );
8212 }
8213 wprintw( w_monster_info_border, " >" );
8214 }
8215
8216 draw_scrollbar( w_monsters_border, iActive, iMaxRows, static_cast<int>( monster_list.size() ),
8217 point_south );
8218 }
8219
8220 wnoutrefresh( w_monsters_border );
8221 wnoutrefresh( w_monster_info_border );
8222 wnoutrefresh( w_monsters );
8223 wnoutrefresh( w_monster_info );
8224 }
8225 } );
8226
8227 cata::optional<tripoint> trail_start;
8228 cata::optional<tripoint> trail_end;
8229 bool trail_end_x = false;
8230 shared_ptr_fast<draw_callback_t> trail_cb = create_trail_callback( trail_start, trail_end,
8231 trail_end_x );
8232 add_draw_callback( trail_cb );
8233
8234 do {
8235 if( action == "UP" ) {
8236 iActive--;
8237 if( iActive < 0 ) {
8238 if( monster_list.empty() ) {
8239 iActive = 0;
8240 } else {
8241 iActive = static_cast<int>( monster_list.size() ) - 1;
8242 }
8243 }
8244 } else if( action == "DOWN" ) {
8245 iActive++;
8246 if( iActive >= static_cast<int>( monster_list.size() ) ) {
8247 iActive = 0;
8248 }
8249 } else if( action == "NEXT_TAB" || action == "PREV_TAB" ) {
8250 u.view_offset = stored_view_offset;
8252 } else if( action == "SAFEMODE_BLACKLIST_REMOVE" ) {
8253 const auto m = dynamic_cast<monster *>( cCurMon );
8254 const std::string monName = ( m != nullptr ) ? m->name() : "human";
8255
8256 if( get_safemode().has_rule( monName, Creature::A_ANY ) ) {
8258 }
8259 } else if( action == "SAFEMODE_BLACKLIST_ADD" ) {
8260 if( !get_safemode().empty() ) {
8261 const auto m = dynamic_cast<monster *>( cCurMon );
8262 const std::string monName = ( m != nullptr ) ? m->name() : "human";
8263
8264 get_safemode().add_rule( monName, Creature::A_ANY, get_option<int>( "SAFEMODEPROXIMITY" ),
8266 }
8267 } else if( action == "look" ) {
8268 hide_ui = true;
8269 ui.mark_resize();
8270 look_around();
8271 hide_ui = false;
8272 ui.mark_resize();
8273 } else if( action == "fire" ) {
8274 if( cCurMon != nullptr && rl_dist( u.pos(), cCurMon->pos() ) <= max_gun_range ) {
8275 u.last_target = shared_from( *cCurMon );
8277 u.view_offset = stored_view_offset;
8278 return game::vmenu_ret::FIRE;
8279 }
8280 }
8281
8282 if( iActive >= 0 && static_cast<size_t>( iActive ) < monster_list.size() ) {
8283 cCurMon = monster_list[iActive];
8284 iActivePos = cCurMon->pos() - u.pos();
8285 centerlistview( iActivePos, width );
8286 trail_start = u.pos();
8287 trail_end = cCurMon->pos();
8288 // Actually accessed from the terrain overlay callback `trail_cb` in the
8289 // call to `ui_manager::redraw`.
8290 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
8291 trail_end_x = false;
8292 } else {
8293 cCurMon = nullptr;
8294 iActivePos = tripoint_zero;
8295 u.view_offset = stored_view_offset;
8296 trail_start = trail_end = cata::nullopt;
8297 }
8299
8301
8302 action = ctxt.handle_input();
8303 } while( action != "QUIT" );
8304
8305 u.view_offset = stored_view_offset;
8306
8307 return game::vmenu_ret::QUIT;
8308}
double recoil
Definition: character.h:560
nc_color symbol_color() const override
Color's character's tile's background.
Definition: character.cpp:6124
static const std::pair< translation, nc_color > & get_attitude_ui_data(Attitude att)
Creature Attitude as String and color.
Definition: creature.cpp:1857
virtual const tripoint & pos() const =0
virtual int print_info(const catacurses::window &w, int vStart, int vLines, int column) const =0
Write information about this creature.
shared_ptr_fast< T > shared_from(const T &critter)
Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature).
Definition: game.cpp:4896
bool bVMonsterLookFire
Definition: game.h:1083
int gun_range(const player *p) const
The weapons range in map squares.
Definition: item.cpp:7195
npc_attitude get_attitude() const
Definition: npc.cpp:3136
weak_ptr_fast< Creature > last_target
Definition: player.h:647
bool has_rule(const std::string &rule_in, Creature::Attitude attitude_in)
void remove_rule(const std::string &rule_in, Creature::Attitude attitude_in)
static nc_color color(const T_t &t)
@ RULE_BLACKLISTED
Definition: enums.h:54
constexpr double MAX_RECOIL
std::string npc_attitude_name(npc_attitude att)
Definition: npc.cpp:2542
std::pair< std::string, nc_color > get_hp_bar(const int cur_hp, const int max_hp, const bool is_mon)
Definition: output.cpp:1604
size_t shortcut_print(const catacurses::window &w, const point &p, nc_color text_color, nc_color shortcut_color, const std::string &fmt)
Definition: output.cpp:1543

References _, Creature::A_ANY, action, add_draw_callback(), safemode::add_rule(), bVMonsterLookFire, c_light_gray, c_light_green, c_magenta, c_white, c_yellow, calcStartPos(), centerlistview(), CHANGE_TAB, color(), create_trail_callback(), direction_from(), direction_name_short(), draw_custom_border(), draw_scrollbar(), FIRE, g, npc::get_attitude(), Creature::get_attitude_ui_data(), get_hp_bar(), get_safemode(), catacurses::getmaxy(), item::gun_range(), input_context::handle_input(), safemode::has_rule(), hilite(), invalidate_main_ui_adaptor(), player::last_target, LINE_XOXO, LINE_XOXX, LINE_XXXO, look_around(), m, MAX_RECOIL, catacurses::mvwprintw(), mvwprintz(), map::name(), catacurses::newwin(), npc_attitude_name(), safemode::npc_type_name(), cata::nullopt, point_east, point_south, point_zero, Creature::pos(), Character::pos(), input_context::press_x(), Creature::print_info(), QUIT, Character::recoil, ui_manager::redraw(), input_context::register_action(), safemode::remove_rule(), rl_dist(), RULE_BLACKLISTED, shared_from(), shortcut_print(), Character::symbol_color(), TERMX, TERMY, to_translation(), trim_and_print(), tripoint_zero, u, player::view_offset, Character::weapon, catacurses::werase(), catacurses::wnoutrefresh(), catacurses::wprintw(), and wprintz().

Referenced by list_items_monsters().

◆ load() [1/2]

bool game::load ( const save_t name)
private

Definition at line 2857 of file game.cpp.

2858{
2861 popup.message( "%s", _( "Please wait…\nLoading the save…" ) );
2864
2865 using namespace std::placeholders;
2866
2867 const std::string worldpath = get_world_base_save_path() + "/";
2868 const std::string playerpath = worldpath + name.base_path();
2869
2870 // Now load up the master game data; factions (and more?)
2871 load_master();
2872 u = avatar();
2873 u.name = name.player_name();
2874 // This should be initialized more globally (in player/Character constructor)
2876 if( !read_from_file( playerpath + SAVE_EXTENSION, std::bind( &game::unserialize, this, _1 ) ) ) {
2877 return false;
2878 }
2879
2881
2883
2884 read_from_file_optional( worldpath + name.base_path() + SAVE_EXTENSION_LOG,
2885 std::bind( &memorial_logger::load, &memorial(), _1 ) );
2886
2887#if defined(__ANDROID__)
2888 read_from_file_optional( worldpath + name.base_path() + SAVE_EXTENSION_SHORTCUTS,
2889 std::bind( &game::load_shortcuts, this, _1 ) );
2890#endif
2891
2892 // Now that the player's worn items are updated, their sight limits need to be
2893 // recalculated. (This would be cleaner if u.worn were private.)
2895
2896 if( !gamemode ) {
2897 gamemode = std::make_unique<special_game>();
2898 }
2899
2900 safe_mode = get_option<bool>( "SAFEMODE" ) ? SAFE_MODE_ON : SAFE_MODE_OFF;
2901 mostseen = 0; // ...and mostseen is 0, we haven't seen any monsters yet.
2902
2903 init_autosave();
2904 get_auto_pickup().load_character(); // Load character auto pickup rules
2905 get_auto_notes_settings().load(); // Load character auto notes settings
2906 get_safemode().load_character(); // Load character safemode rules
2907 zone_manager::get_manager().load_zones(); // Load character world zones
2908 read_from_file_optional( get_world_base_save_path() + "/uistate.json", []( std::istream & stream ) {
2909 JsonIn jsin( stream );
2910 uistate.deserialize( jsin );
2911 } );
2912 reload_npcs();
2917 update_map( u );
2918 for( auto &e : u.inv_dump() ) {
2919 e->set_owner( g->u );
2920 }
2921 // legacy, needs to be here as we access the map.
2922 if( !u.getID().is_valid() ) {
2923 // player does not have a real id, so assign a new one,
2924 u.setID( assign_npc_id() );
2925 // The vehicle stores the IDs of the boarded players, so update it, too.
2926 if( u.in_vehicle ) {
2928 u.pos() ).part_with_feature( "BOARDABLE", true ) ) {
2929 vp->part().passenger_id = u.getID();
2930 }
2931 }
2932 }
2933
2934 // populate calendar caches now, after active world is set, but before we do
2935 // anything else, to ensure they pick up the correct value from the save's
2936 // worldoptions
2937 calendar::set_eternal_season( ::get_option<bool>( "ETERNAL_SEASON" ) );
2938 calendar::set_season_length( ::get_option<int>( "SEASON_LENGTH" ) );
2939
2940 u.reset();
2941
2942 return true;
2943}
bool read_from_file(const std::string &path, const std::function< void(std::istream &)> &reader)
Try to open and read from given file using the given callback.
bool read_from_file_optional(const std::string &path, const std::function< void(std::istream &)> &reader)
void setID(character_id i, bool force=false)
Definition: character.cpp:466
std::vector< item * > inv_dump()
Definition: character.cpp:8973
void recalc_sight_limits()
Modifies the player's sight values Must be called when any of the following change: This must be call...
Definition: character.cpp:1706
void reset() override
Handles stat and bonus reset.
Definition: character.cpp:3625
Definition: json.h:177
Definition: avatar.h:54
void load_map_memory()
Definition: avatar.cpp:134
bool is_valid() const
Definition: character_id.h:19
void validate_linked_vehicles()
validate towed vehicles so they get linked up again after a load
Definition: game.cpp:1980
void reload_npcs()
Unloads, then loads the NPCs.
Definition: game.cpp:960
void validate_camps()
validate camps to ensure they are on the overmap list
Definition: game.cpp:2038
void load_master()
Definition: game.cpp:2826
void validate_mounted_npcs()
Definition: game.cpp:1995
character_id assign_npc_id()
Definition: game.cpp:3943
void unserialize(std::istream &fin)
Definition: savegame.cpp:167
void init_autosave()
Definition: game.cpp:11796
void validate_npc_followers()
validate list of followers to account for overmap buffers
Definition: game.cpp:2014
void load(std::istream &fin)
Loads the data in a memorial file from the given ifstream.
void load_character()
Create a popup on the UI stack that gets displayed but receives no input itself.
Definition: popup.h:276
void deserialize(const JsonObject &jo)
time_point nextweather
Definition: weather.h:205
void load_zones()
Definition: clzones.cpp:1216
static const std::string SAVE_EXTENSION(".sav")
static const std::string SAVE_EXTENSION_SHORTCUTS(".shortcuts")
static const std::string SAVE_EXTENSION_LOG(".log")
void set_season_length(int dur)
Definition: calendar.cpp:478
void set_eternal_season(bool is_eternal_season)
Definition: calendar.cpp:470

References _, assign_npc_id(), uistatedata::deserialize(), g, gamemode, get_auto_notes_settings(), get_auto_pickup(), zone_manager::get_manager(), get_safemode(), get_weather, get_world_base_save_path(), Character::getID(), Character::in_vehicle, init_autosave(), Character::inv_dump(), character_id::is_valid(), auto_notes::auto_note_settings::load(), memorial_logger::load(), auto_pickup::player_settings::load_character(), safemode::load_character(), avatar::load_map_memory(), load_master(), zone_manager::load_zones(), m, memorial(), mostseen, Character::name, om_direction::name(), weather_manager::nextweather, optional_vpart_position::part_with_feature(), popup(), Character::pos(), read_from_file(), read_from_file_optional(), Character::recalc_sight_limits(), ui_manager::redraw(), refresh_display(), reload_npcs(), Character::reset(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAVE_EXTENSION(), SAVE_EXTENSION_LOG(), SAVE_EXTENSION_SHORTCUTS(), calendar::set_eternal_season(), calendar::set_season_length(), Character::setID(), calendar::start_of_cataclysm, calendar::turn, u, uistate, unserialize(), update_map(), validate_camps(), validate_linked_vehicles(), validate_mounted_npcs(), validate_npc_followers(), map::veh_at(), and Character::weapon.

◆ load() [2/2]

bool game::load ( const std::string &  world)

Attempt to load first valid save (if any) in world.

Definition at line 2833 of file game.cpp.

2834{
2835 world_generator->init();
2836 const WORLDPTR wptr = world_generator->get_world( world );
2837 if( !wptr ) {
2838 return false;
2839 }
2840 if( wptr->world_saves.empty() ) {
2841 debugmsg( "world '%s' contains no saves", world );
2842 return false;
2843 }
2844
2845 try {
2846 world_generator->set_active_world( wptr );
2847 g->setup();
2848 g->load( wptr->world_saves.front() );
2849 } catch( const std::exception &err ) {
2850 debugmsg( "cannot load world '%s': %s", world, err.what() );
2851 return false;
2852 }
2853
2854 return true;
2855}
std::vector< save_t > world_saves
Definition: worldfactory.h:61

References debugmsg, g, world_generator, and WORLD::world_saves.

Referenced by quickload().

◆ load_core_data()

void game::load_core_data ( loading_ui ui)

Loads core dynamic data.

May throw.

Definition at line 438 of file game.cpp.

439{
440 // core data can be loaded only once and must be first
441 // anyway.
443
445}
void unload_data()
Deletes and unloads all the data previously loaded with load_data_from_path.
Definition: init.cpp:524
std::string jsondir()
Definition: path_info.cpp:230

References DynamicDataLoader::get_instance(), PATH_INFO::jsondir(), load_data_from_dir(), and DynamicDataLoader::unload_data().

Referenced by check_mod_data(), dump_stats(), and setup().

◆ load_data_from_dir()

void game::load_data_from_dir ( const std::string &  path,
const std::string &  src,
loading_ui ui 
)
protected

Loads dynamic data from the given directory.

May throw.

Definition at line 447 of file game.cpp.

448{
450}
void load_data_from_path(const std::string &path, const std::string &src, loading_ui &ui)
Load all data from json files located in the path (recursive).
Definition: init.cpp:454

References DynamicDataLoader::get_instance(), and DynamicDataLoader::load_data_from_path().

Referenced by check_mod_data(), load_core_data(), and load_packs().

◆ load_map() [1/2]

void game::load_map ( const tripoint pos_sm)

Load the main map at given location, see map::load, in global, absolute submap coordinates.

Definition at line 634 of file game.cpp.

635{
636 // TODO: fix point types
637 load_map( tripoint_abs_sm( pos_sm ) );
638}
void load_map(const tripoint &pos_sm)
Load the main map at given location, see map::load, in global, absolute submap coordinates.
Definition: game.cpp:634
coords::coord_point< tripoint, coords::origin::abs, coords::sm > tripoint_abs_sm
Definition: coordinates.h:490

References load_map().

Referenced by load_map(), place_player_overmap(), start_game(), and unserialize().

◆ load_map() [2/2]

void game::load_map ( const tripoint_abs_sm pos_sm)

Definition at line 640 of file game.cpp.

641{
642 m.load( pos_sm, true );
643 grid_tracker_ptr->load( m );
644}
void load(const tripoint &w, bool update_vehicles)
Load submaps into grid.
Definition: map.cpp:6494

References grid_tracker_ptr, map::load(), and m.

◆ load_master()

void game::load_master ( )
private

Definition at line 2826 of file game.cpp.

2827{
2828 using namespace std::placeholders;
2829 const auto datafile = get_world_base_save_path() + "/" + SAVE_MASTER;
2830 read_from_file_optional( datafile, std::bind( &game::unserialize_master, this, _1 ) );
2831}
void unserialize_master(std::istream &fin)
Definition: savegame.cpp:1188
static const std::string SAVE_MASTER("master.gsav")

References get_world_base_save_path(), read_from_file_optional(), SAVE_MASTER(), and unserialize_master().

Referenced by load(), and start_game().

◆ load_npcs()

void game::load_npcs ( )

Makes any nearby NPCs on the overmap active.

Definition at line 898 of file game.cpp.

899{
900 const int radius = HALF_MAPSIZE - 1;
901 // uses submap coordinates
902 std::vector<shared_ptr_fast<npc>> just_added;
903 for( const auto &temp : overmap_buffer.get_npcs_near_player( radius ) ) {
904 const character_id &id = temp->getID();
905 const auto found = std::find_if( active_npc.begin(), active_npc.end(),
906 [id]( const shared_ptr_fast<npc> &n ) {
907 return n->getID() == id;
908 } );
909 if( found != active_npc.end() ) {
910 continue;
911 }
912 if( temp->is_active() ) {
913 continue;
914 }
915 if( temp->has_companion_mission() ) {
916 continue;
917 }
918
919 const tripoint sm_loc = temp->global_sm_location();
920 // NPCs who are out of bounds before placement would be pushed into bounds
921 // This can cause NPCs to teleport around, so we don't want that
922 if( sm_loc.x < get_levx() || sm_loc.x >= get_levx() + MAPSIZE ||
923 sm_loc.y < get_levy() || sm_loc.y >= get_levy() + MAPSIZE ||
924 ( sm_loc.z != get_levz() && !m.has_zlevels() ) ) {
925 continue;
926 }
927
928 add_msg( m_debug, "game::load_npcs: Spawning static NPC, %d:%d:%d (%d:%d:%d)",
929 get_levx(), get_levy(), get_levz(), sm_loc.x, sm_loc.y, sm_loc.z );
930 temp->place_on_map();
931 if( !m.inbounds( temp->pos() ) ) {
932 continue;
933 }
934 // In the rare case the npc was marked for death while
935 // it was on the overmap. Kill it.
936 if( temp->marked_for_death ) {
937 temp->die( nullptr );
938 } else {
939 active_npc.push_back( temp );
940 just_added.push_back( temp );
941 }
942 }
943
944 for( const auto &npc : just_added ) {
945 npc->on_load();
946 }
947
948 npcs_dirty = false;
949}
void on_load()
Retroactively update npc.
Definition: npc.cpp:2655
static constexpr int MAPSIZE

References active_npc, add_msg(), get_levx(), get_levy(), get_levz(), overmapbuffer::get_npcs_near_player(), HALF_MAPSIZE, map::has_zlevels(), map::inbounds(), m, m_debug, MAPSIZE, npcs_dirty, npc::on_load(), overmap_buffer, tripoint::x, tripoint::y, and tripoint::z.

Referenced by do_turn(), perhaps_add_random_npc(), place_player_overmap(), reload_npcs(), save_cyborg(), spawn_hallucination(), start_game(), and update_map().

◆ load_packs()

bool game::load_packs ( const std::string &  msg,
const std::vector< mod_id > &  packs,
loading_ui ui 
)

Load content packs.

Parameters
msgstring to display whilst loading prompt
packscontent packs to load in correct dependent order
uistructure for load progress display
Returns
true if all packs were found, false if any were missing

Definition at line 2981 of file game.cpp.

2982{
2983 ui.new_context( msg );
2984 std::vector<mod_id> missing;
2985 std::vector<mod_id> available;
2986
2987 for( const mod_id &e : packs ) {
2988 if( e.is_valid() ) {
2989 available.emplace_back( e );
2990 ui.add_entry( e->name() );
2991 } else {
2992 missing.push_back( e );
2993 }
2994 }
2995
2996 ui.show();
2997 for( const auto &e : available ) {
2998 const MOD_INFORMATION &mod = *e;
2999 load_data_from_dir( mod.path, mod.ident.str(), ui );
3000 ui.proceed();
3001 }
3002
3003 for( const auto &e : missing ) {
3004 debugmsg( "unknown content %s", e.c_str() );
3005 }
3006
3007 return missing.empty();
3008}

References available, string_id< T >::c_str(), debugmsg, string_id< T >::is_valid(), load_data_from_dir(), and MOD_INFORMATION::name().

Referenced by dump_stats().

◆ load_static_data()

void game::load_static_data ( )

Loads static data that does not depend on mods or similar.

Definition at line 324 of file game.cpp.

325{
326 // UI stuff, not mod-specific per definition
327 inp_mngr.init(); // Load input config JSON
328 // Init mappings for loading the json stuff
330 fullscreen = false;
331 was_fullscreen = false;
332 show_panel_adm = false;
334
335 // These functions do not load stuff from json.
336 // The content they load/initialize is hardcoded into the program.
337 // Therefore they can be loaded here.
338 // If this changes (if they load data from json), they have to
339 // be moved to game::load_mod or game::load_core_data
340
343}
bool was_fullscreen
Definition: game.h:1065
bool fullscreen
Definition: game.h:1064
void init()
Initializes the input manager, aka loads the input mapping configuration JSON.
Definition: input.cpp:111
void init()
Definition: panels.cpp:2309
void load_global()

References fullscreen, get_auto_pickup(), DynamicDataLoader::get_instance(), panel_manager::get_manager(), get_safemode(), input_manager::init(), panel_manager::init(), inp_mngr, auto_pickup::player_settings::load_global(), safemode::load_global(), show_panel_adm, and was_fullscreen.

◆ load_world_modfiles()

void game::load_world_modfiles ( loading_ui ui)

Loads core data and mods from the active world.

May throw.

Definition at line 2945 of file game.cpp.

2946{
2947 auto &mods = world_generator->active_world->active_mod_order;
2948
2949 // remove any duplicates whilst preserving order (fixes #19385)
2950 std::set<mod_id> found;
2951 mods.erase( std::remove_if( mods.begin(), mods.end(), [&found]( const mod_id & e ) {
2952 if( found.count( e ) ) {
2953 return true;
2954 } else {
2955 found.insert( e );
2956 return false;
2957 }
2958 } ), mods.end() );
2959
2960 // require at least one core mod (saves before version 6 may implicitly require dda pack)
2961 if( std::none_of( mods.begin(), mods.end(), []( const mod_id & e ) {
2962 return e->core;
2963} ) ) {
2964 mods.insert( mods.begin(), mod_id( "dda" ) );
2965 }
2966
2968 // this code does not care about mod dependencies,
2969 // it assumes that those dependencies are static and
2970 // are resolved during the creation of the world.
2971 // That means world->active_mod_order contains a list
2972 // of mods in the correct order.
2973 load_packs( _( "Loading files" ), mods, ui );
2974
2975 // Load additional mods from that world-specific folder
2976 load_data_from_dir( get_world_base_save_path() + "/mods", "custom", ui );
2977
2979}
void load_artifacts(const std::string &path)
Definition: artifact.cpp:1098
static const std::string SAVE_ARTIFACTS("artifacts.gsav")

References world_generator.

Referenced by setup().

◆ look_around() [1/2]

cata::optional< tripoint > game::look_around ( )

Definition at line 6852 of file game.cpp.

6853{
6855 look_around_result result = look_around( /*show_window=*/true, center, center, false, false,
6856 false );
6857 return result.position;
6858}

References center, look_around(), Character::pos(), u, and player::view_offset.

Referenced by handle_action(), list_monsters(), look_around(), peek(), and zones_manager().

◆ look_around() [2/2]

look_around_result game::look_around ( bool  show_window,
tripoint center,
const tripoint start_point,
bool  has_first_point,
bool  select_zone,
bool  peeking,
bool  is_moving_zone = false,
const tripoint end_point = tripoint_zero 
)
Parameters
show_windowdisplay the info window that holds the tile information in the position.
centerused to calculate the u.view_offset, could center the screen to the position it represents
start_pointthe start point of the targeting zone, also the initial local position of the cursor
has_first_pointshould be true if the first point has been selected when editing the zone
select_zonetrue if the zone is being edited
peekingdetermines if the player is peeking
is_moving_zonetrue if the zone is being moved, false by default
end_pointthe end point of the targeting zone, only used if is_moving_zone is true, default is tripoint_zero
Returns
look_around_result

Definition at line 6860 of file game.cpp.

6863{
6864 bVMonsterLookFire = false;
6865 // TODO: Make this `true`
6866 const bool allow_zlev_move = m.has_zlevels() && get_option<bool>( "FOV_3D" );
6867
6869
6870 tripoint lp = is_moving_zone ? ( start_point + end_point ) / 2 : start_point; // cursor
6871 int &lx = lp.x;
6872 int &ly = lp.y;
6873 int &lz = lp.z;
6874
6875 int soffset = get_option<int>( "FAST_SCROLL_OFFSET" );
6876 bool fast_scroll = false;
6877
6878 std::unique_ptr<ui_adaptor> ui;
6879 catacurses::window w_info;
6880 if( show_window ) {
6881 ui = std::make_unique<ui_adaptor>();
6882 ui->on_screen_resize( [&]( ui_adaptor & ui ) {
6883 int panel_width = panel_manager::get_manager().get_current_layout().begin()->get_width();
6885
6886 // If particularly small, base height on panel width irrespective of other elements.
6887 // Value here is attempting to get a square-ish result assuming 1x2 proportioned font.
6888 if( height < panel_width / 2 ) {
6889 height = panel_width / 2;
6890 }
6891
6892 int la_y = 0;
6893 int la_x = TERMX - panel_width;
6894 std::string position = get_option<std::string>( "LOOKAROUND_POSITION" );
6895 if( position == "left" ) {
6896 if( get_option<std::string>( "SIDEBAR_POSITION" ) == "right" ) {
6898 } else {
6899 la_x = panel_manager::get_manager().get_width_left() - panel_width;
6900 }
6901 }
6902 int la_h = height;
6903 int la_w = panel_width;
6904 w_info = catacurses::newwin( la_h, la_w, point( la_x, la_y ) );
6905
6906 ui.position_from_window( w_info );
6907 } );
6908 ui->mark_resize();
6909 }
6910
6911 std::string action;
6912 input_context ctxt( "LOOK" );
6913 ctxt.set_iso( true );
6914 ctxt.register_directions();
6915 ctxt.register_action( "COORDINATE" );
6916 ctxt.register_action( "LEVEL_UP" );
6917 ctxt.register_action( "LEVEL_DOWN" );
6918 ctxt.register_action( "TOGGLE_FAST_SCROLL" );
6919 ctxt.register_action( "EXTENDED_DESCRIPTION" );
6920 ctxt.register_action( "SELECT" );
6921 if( peeking ) {
6922 ctxt.register_action( "throw_blind" );
6923 }
6924 if( !select_zone ) {
6925 ctxt.register_action( "TRAVEL_TO" );
6926 ctxt.register_action( "LIST_ITEMS" );
6927 }
6928 ctxt.register_action( "MOUSE_MOVE" );
6929 ctxt.register_action( "CENTER" );
6930
6931 ctxt.register_action( "debug_scent" );
6932 ctxt.register_action( "debug_scent_type" );
6933 ctxt.register_action( "debug_temp" );
6934 ctxt.register_action( "debug_visibility" );
6935 ctxt.register_action( "debug_lighting" );
6936 ctxt.register_action( "debug_radiation" );
6937 ctxt.register_action( "debug_submap_grid" );
6938 ctxt.register_action( "debug_hour_timer" );
6939 ctxt.register_action( "CONFIRM" );
6940 ctxt.register_action( "QUIT" );
6941 ctxt.register_action( "HELP_KEYBINDINGS" );
6942 if( use_tiles ) {
6943 ctxt.register_action( "zoom_out" );
6944 ctxt.register_action( "zoom_in" );
6945 }
6946#if defined(TILES)
6947 ctxt.register_action( "toggle_pixel_minimap" );
6948#endif // TILES
6949
6950 const int old_levz = get_levz();
6951 const int min_levz = std::max( old_levz - fov_3d_z_range, -OVERMAP_DEPTH );
6952 const int max_levz = std::min( old_levz + fov_3d_z_range, OVERMAP_HEIGHT );
6953
6954 m.update_visibility_cache( old_levz );
6956
6957 bool blink = true;
6959
6960 shared_ptr_fast<draw_callback_t> ter_indicator_cb;
6961
6962 if( show_window && ui ) {
6963 ui->on_redraw( [&]( const ui_adaptor & ) {
6964 werase( w_info );
6965 draw_border( w_info );
6966
6967 center_print( w_info, 0, c_white, string_format( _( "< <color_green>Look Around</color> >" ) ) );
6968
6969 std::string extended_descr_text = string_format( _( "%s - %s" ),
6970 ctxt.get_desc( "EXTENDED_DESCRIPTION" ),
6971 ctxt.get_action_name( "EXTENDED_DESCRIPTION" ) );
6972 std::string fast_scroll_text = string_format( _( "%s - %s" ),
6973 ctxt.get_desc( "TOGGLE_FAST_SCROLL" ),
6974 ctxt.get_action_name( "TOGGLE_FAST_SCROLL" ) );
6975#if defined(TILES)
6976 std::string pixel_minimap_text = string_format( _( "%s - %s" ),
6977 ctxt.get_desc( "toggle_pixel_minimap" ),
6978 ctxt.get_action_name( "toggle_pixel_minimap" ) );
6979#endif // TILES
6980
6981 center_print( w_info, getmaxy( w_info ) - 2, c_light_gray, extended_descr_text );
6982 mvwprintz( w_info, point( 1, getmaxy( w_info ) - 1 ), fast_scroll ? c_light_green : c_green,
6983 fast_scroll_text );
6984#if defined(TILES)
6985 right_print( w_info, getmaxy( w_info ) - 1, 1, pixel_minimap_option ? c_light_green : c_green,
6986 pixel_minimap_text );
6987#endif // TILES
6988
6989 int first_line = 1;
6990 const int last_line = getmaxy( w_info ) - 3;
6991 pre_print_all_tile_info( lp, w_info, first_line, last_line, cache );
6992
6993 wnoutrefresh( w_info );
6994 } );
6995 ter_indicator_cb = make_shared_fast<draw_callback_t>( [&]() {
6996 draw_look_around_cursor( lp, cache );
6997 } );
6998 add_draw_callback( ter_indicator_cb );
6999 }
7000
7001 cata::optional<tripoint> zone_start;
7002 cata::optional<tripoint> zone_end;
7003 bool zone_blink = false;
7004 bool zone_cursor = true;
7005 shared_ptr_fast<draw_callback_t> zone_cb = create_zone_callback( zone_start, zone_end, zone_blink,
7006 zone_cursor, is_moving_zone );
7007 add_draw_callback( zone_cb );
7008
7009 is_looking = true;
7010 const tripoint prev_offset = u.view_offset;
7011#if defined(TILES)
7012 const int prev_tileset_zoom = tileset_zoom;
7013 while( is_moving_zone && square_dist( start_point, end_point ) > 256 / get_zoom() &&
7014 get_zoom() != 4 ) {
7015 zoom_out();
7016 }
7018#endif
7019 do {
7020 u.view_offset = center - u.pos();
7021 if( select_zone ) {
7022 if( has_first_point ) {
7023 zone_start = start_point;
7024 zone_end = lp;
7025 } else {
7026 zone_start = lp;
7027 zone_end = cata::nullopt;
7028 }
7029 // Actually accessed from the terrain overlay callback `zone_cb` in the
7030 // call to `ui_manager::redraw`.
7031 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
7032 zone_blink = blink;
7033 }
7034
7035 if( is_moving_zone ) {
7036 zone_start = lp - ( start_point + end_point ) / 2 + start_point;
7037 zone_end = lp - ( start_point + end_point ) / 2 + end_point;
7038 // Actually accessed from the terrain overlay callback `zone_cb` in the
7039 // call to `ui_manager::redraw`.
7040 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
7041 zone_blink = blink;
7042 }
7045 if( ( select_zone && has_first_point ) || is_moving_zone ) {
7046 ctxt.set_timeout( BLINK_SPEED );
7047 }
7048
7049 //Wait for input
7050 // only specify a timeout here if "EDGE_SCROLL" is enabled
7051 // otherwise use the previously set timeout
7052 const tripoint edge_scroll = mouse_edge_scrolling_terrain( ctxt );
7053 const int scroll_timeout = get_option<int>( "EDGE_SCROLL" );
7054 const bool edge_scrolling = edge_scroll != tripoint_zero && scroll_timeout >= 0;
7055 if( edge_scrolling ) {
7056 action = ctxt.handle_input( scroll_timeout );
7057 } else {
7058 action = ctxt.handle_input();
7059 }
7060 if( ( action == "LEVEL_UP" || action == "LEVEL_DOWN" || action == "MOUSE_MOVE" ||
7061 ctxt.get_direction( action ) ) && ( ( select_zone && has_first_point ) || is_moving_zone ) ) {
7062 blink = true; // Always draw blink symbols when moving cursor
7063 } else if( action == "TIMEOUT" ) {
7064 blink = !blink;
7065 }
7066 if( action == "LIST_ITEMS" ) {
7068 } else if( action == "TOGGLE_FAST_SCROLL" ) {
7069 fast_scroll = !fast_scroll;
7070 } else if( action == "toggle_pixel_minimap" ) {
7072
7073 if( show_window && ui ) {
7074 ui->mark_resize();
7075 }
7076 } else if( action == "LEVEL_UP" || action == "LEVEL_DOWN" ) {
7077 if( !allow_zlev_move ) {
7078 continue;
7079 }
7080
7081 const int dz = ( action == "LEVEL_UP" ? 1 : -1 );
7082 lz = clamp( lz + dz, min_levz, max_levz );
7083 center.z = clamp( center.z + dz, min_levz, max_levz );
7084
7085 add_msg( m_debug, "levx: %d, levy: %d, levz: %d", get_levx(), get_levy(), center.z );
7086 u.view_offset.z = center.z - u.posz();
7088 } else if( action == "TRAVEL_TO" ) {
7089 if( !u.sees( lp ) ) {
7090 add_msg( _( "You can't see that destination." ) );
7091 continue;
7092 }
7093
7094 auto route = m.route( u.pos(), lp, u.get_pathfinding_settings(), u.get_path_avoid() );
7095 if( route.size() > 1 ) {
7096 route.pop_back();
7097 u.set_destination( route );
7098 } else {
7099 add_msg( m_info, _( "You can't travel there." ) );
7100 continue;
7101 }
7102 } else if( action == "debug_scent" || action == "debug_scent_type" ) {
7104 display_scent();
7105 }
7106 } else if( action == "debug_temp" ) {
7109 }
7110 } else if( action == "debug_lighting" ) {
7113 }
7114 } else if( action == "debug_transparency" ) {
7117 }
7118 } else if( action == "debug_radiation" ) {
7121 }
7122 } else if( action == "debug_submap_grid" ) {
7123 g->debug_submap_grid_overlay = !g->debug_submap_grid_overlay;
7124 } else if( action == "debug_hour_timer" ) {
7126 } else if( action == "EXTENDED_DESCRIPTION" ) {
7128 } else if( action == "CENTER" ) {
7129 center = u.pos();
7130 lp = u.pos();
7131 u.view_offset.z = 0;
7132 } else if( action == "MOUSE_MOVE" || action == "TIMEOUT" ) {
7133 // This block is structured this way so that edge scroll can work
7134 // whether the mouse is moving at the edge or simply stationary
7135 // at the edge. But even if edge scroll isn't in play, there's
7136 // other things for us to do here.
7137
7138 if( edge_scrolling ) {
7139 center += action == "MOUSE_MOVE" ? edge_scroll * 2 : edge_scroll;
7140 } else if( action == "MOUSE_MOVE" ) {
7141 const cata::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
7142 if( mouse_pos ) {
7143 lx = mouse_pos->x;
7144 ly = mouse_pos->y;
7145 }
7146 }
7147 } else if( cata::optional<tripoint> vec = ctxt.get_direction( action ) ) {
7148 if( fast_scroll ) {
7149 vec->x *= soffset;
7150 vec->y *= soffset;
7151 }
7152
7153 lx = lx + vec->x;
7154 ly = ly + vec->y;
7155 center.x = center.x + vec->x;
7156 center.y = center.y + vec->y;
7157 } else if( action == "throw_blind" ) {
7158 result.peek_action = PA_BLIND_THROW;
7159 } else if( action == "zoom_in" ) {
7160 center.x = lp.x;
7161 center.y = lp.y;
7162 zoom_in();
7164 } else if( action == "zoom_out" ) {
7165 center.x = lp.x;
7166 center.y = lp.y;
7167 zoom_out();
7169 }
7170 } while( action != "QUIT" && action != "CONFIRM" && action != "SELECT" && action != "TRAVEL_TO" &&
7171 action != "throw_blind" );
7172
7173 if( m.has_zlevels() && center.z != old_levz ) {
7174 m.invalidate_map_cache( old_levz );
7175 m.build_map_cache( old_levz );
7176 u.view_offset.z = 0;
7177 }
7178
7179 ctxt.reset_timeout();
7180 u.view_offset = prev_offset;
7181 zone_cb = nullptr;
7182 is_looking = false;
7183
7185 bVMonsterLookFire = true;
7186
7187 if( action == "CONFIRM" || action == "SELECT" ) {
7188 result.position = is_moving_zone ? zone_start : lp;
7189 }
7190
7191#if defined(TILES)
7192 if( is_moving_zone && get_zoom() != prev_tileset_zoom ) {
7193 // Reset the tileset zoom to the previous value
7194 set_zoom( prev_tileset_zoom );
7196 }
7197#endif
7198
7199 return result;
7200}
int fov_3d_z_range
3D FoV range, in Z levels, in both directions.
bool pixel_minimap_option
Whether to show the pixel minimap.
tripoint mouse_edge_scrolling_terrain(input_context &ctxt)
Used to implement mouse "edge scrolling".
Definition: game.cpp:2407
void set_zoom(int level)
Definition: game.cpp:7351
void draw_look_around_cursor(const tripoint &lp, const visibility_variables &cache)
Definition: game.cpp:5965
void extended_description(const tripoint &p)
Long description of (visible) things at tile.
void pre_print_all_tile_info(const tripoint &lp, const catacurses::window &w_info, int &line, int last_line, const visibility_variables &cache)
Definition: game.cpp:6839
int get_zoom() const
Definition: game.cpp:7363
const visibility_variables & get_visibility_variables_cache() const
Definition: map.cpp:5615
void invalidate_map_cache(const int zlev)
Definition: map.h:458
std::vector< window_panel > & get_current_layout()
Definition: panels.cpp:2277
int square_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:505
static shared_ptr_fast< game::draw_callback_t > create_zone_callback(const cata::optional< tripoint > &zone_start, const cata::optional< tripoint > &zone_end, const bool &zone_blink, const bool &zone_cursor, const bool &is_moving_zone=false)
Definition: game.cpp:3402
@ PA_BLIND_THROW
Definition: game.h:122
static constexpr int OVERMAP_HEIGHT
static constexpr int BLINK_SPEED
static constexpr int OVERMAP_DEPTH
int right_print(const catacurses::window &w, const int line, const int right_indent, const nc_color &FG, const std::string &text)
Definition: output.cpp:461

References _, action, add_draw_callback(), add_msg(), BLINK_SPEED, map::build_map_cache(), bVMonsterLookFire, c_green, c_light_gray, c_light_green, c_white, center, center_print(), clamp(), create_zone_callback(), display_lighting(), display_radiation(), display_scent(), display_temperature(), display_transparency(), draw_border(), draw_look_around_cursor(), extended_description(), fov_3d_z_range, g, input_context::get_action_name(), input_context::get_coordinates(), panel_manager::get_current_layout(), input_context::get_desc(), input_context::get_direction(), get_levx(), get_levy(), get_levz(), panel_manager::get_manager(), Character::get_path_avoid(), Character::get_pathfinding_settings(), map::get_visibility_variables_cache(), panel_manager::get_width_left(), get_zoom(), catacurses::getmaxy(), input_context::handle_input(), map::has_zlevels(), invalidate_main_ui_adaptor(), map::invalidate_map_cache(), is_looking, MAP_SHARING::isCompetitive(), MAP_SHARING::isDebugger(), list_items_monsters(), m, m_debug, m_info, mark_main_ui_adaptor_resize(), mouse_edge_scrolling_terrain(), mvwprintz(), catacurses::newwin(), cata::nullopt, OVERMAP_DEPTH, OVERMAP_HEIGHT, PA_BLIND_THROW, pixel_minimap_option, Character::pos(), Character::posz(), pre_print_all_tile_info(), ui_manager::redraw(), reenter_fullscreen(), input_context::register_action(), input_context::register_directions(), input_context::reset_timeout(), right_print(), map::route(), Character::sees(), Character::set_destination(), input_context::set_iso(), input_context::set_timeout(), set_zoom(), square_dist(), string_format(), temp_exit_fullscreen(), TERMX, TERMY, tileset_zoom, toggle_debug_hour_timer(), toggle_pixel_minimap(), tripoint_zero, u, map::update_visibility_cache(), use_tiles, player::view_offset, w_pixel_minimap, w_terrain, catacurses::werase(), catacurses::wnoutrefresh(), tripoint::x, tripoint::y, tripoint::z, zoom_in(), and zoom_out().

◆ look_debug()

cata::optional< tripoint > game::look_debug ( )

Definition at line 5958 of file game.cpp.

5959{
5960 editmap edit;
5961 return edit.edit();
5962}
cata::optional< tripoint > edit()
Definition: editmap.cpp:339

References editmap::edit().

◆ mark_main_ui_adaptor_resize()

void game::mark_main_ui_adaptor_resize ( ) const

Definition at line 3359 of file game.cpp.

3360{
3362 if( ui ) {
3363 ui->mark_resize();
3364 }
3365}

References main_ui_adaptor.

Referenced by handle_action(), look_around(), toggle_fullscreen(), and toggle_pixel_minimap().

◆ memorial()

memorial_logger & game::memorial ( )

Definition at line 3101 of file game.cpp.

3102{
3103 return *memorial_logger_ptr;
3104}

References memorial_logger_ptr.

Referenced by cleanup_at_end(), load(), save_player_data(), win(), win_screen(), and write_memorial_file().

◆ mon_info()

void game::mon_info ( const catacurses::window w,
int  hor_padding = 0 
)

Definition at line 4050 of file game.cpp.

4051{
4052 const monster_visible_info &mon_visible = u.get_mon_visible();
4053 const auto &unique_types = mon_visible.unique_types;
4054 const auto &unique_mons = mon_visible.unique_mons;
4055 const auto &dangerous = mon_visible.dangerous;
4056
4057 const int width = getmaxx( w ) - 2 * hor_padding;
4058 const int maxheight = getmaxy( w );
4059
4060 const int startrow = 0;
4061
4062 // Print the direction headings
4063 // Reminder:
4064 // 7 0 1 unique_types uses these indices;
4065 // 6 8 2 0-7 are provide by direction_from()
4066 // 5 4 3 8 is used for local monsters (for when we explain them below)
4067
4068 const std::array<std::string, 8> dir_labels = {{
4069 _( "North:" ), _( "NE:" ), _( "East:" ), _( "SE:" ),
4070 _( "South:" ), _( "SW:" ), _( "West:" ), _( "NW:" )
4071 }
4072 };
4073 std::array<int, 8> widths;
4074 for( int i = 0; i < 8; i++ ) {
4075 widths[i] = utf8_width( dir_labels[i] );
4076 }
4077 std::array<int, 8> xcoords;
4078 const std::array<int, 8> ycoords = {{ 0, 0, 1, 2, 2, 2, 1, 0 }};
4079 xcoords[0] = xcoords[4] = width / 3;
4080 xcoords[1] = xcoords[3] = xcoords[2] = ( width / 3 ) * 2;
4081 xcoords[5] = xcoords[6] = xcoords[7] = 0;
4082 //for the alignment of the 1,2,3 rows on the right edge
4083 xcoords[2] -= utf8_width( _( "East:" ) ) - utf8_width( _( "NE:" ) );
4084 for( int i = 0; i < 8; i++ ) {
4085 nc_color c = unique_types[i].empty() && unique_mons[i].empty() ? c_dark_gray
4086 : ( dangerous[i] ? c_light_red : c_light_gray );
4087 mvwprintz( w, point( xcoords[i] + hor_padding, ycoords[i] + startrow ), c, dir_labels[i] );
4088 }
4089
4090 // Print the symbols of all monsters in all directions.
4091 for( int i = 0; i < 8; i++ ) {
4092 point pr( xcoords[i] + widths[i] + 1, ycoords[i] + startrow );
4093
4094 // The list of symbols needs a space on each end.
4095 int symroom = ( width / 3 ) - widths[i] - 2;
4096 const int typeshere_npc = unique_types[i].size();
4097 const int typeshere_mon = unique_mons[i].size();
4098 const int typeshere = typeshere_mon + typeshere_npc;
4099 for( int j = 0; j < typeshere && j < symroom; j++ ) {
4100 nc_color c;
4101 std::string sym;
4102 if( symroom < typeshere && j == symroom - 1 ) {
4103 // We've run out of room!
4104 c = c_white;
4105 sym = "+";
4106 } else if( j < typeshere_npc ) {
4107 switch( unique_types[i][j]->get_attitude() ) {
4108 case NPCATT_KILL:
4109 c = c_red;
4110 break;
4111 case NPCATT_FOLLOW:
4112 c = c_light_green;
4113 break;
4114 default:
4115 c = c_pink;
4116 break;
4117 }
4118 sym = "@";
4119 } else {
4120 const mtype &mt = *unique_mons[i][j - typeshere_npc];
4121 c = mt.color;
4122 sym = mt.sym;
4123 }
4124 mvwprintz( w, pr, c, sym );
4125
4126 pr.x++;
4127 }
4128 }
4129
4130 // Now we print their full names!
4131
4132 std::set<const mtype *> listed_mons;
4133
4134 // Start printing monster names on row 4. Rows 0-2 are for labels, and row 3
4135 // is blank.
4136 point pr( hor_padding, 4 + startrow );
4137
4138 // Print monster names, starting with those at location 8 (nearby).
4139 for( int j = 8; j >= 0 && pr.y < maxheight; j-- ) {
4140 // Separate names by some number of spaces (more for local monsters).
4141 int namesep = ( j == 8 ? 2 : 1 );
4142 for( const mtype *type : unique_mons[j] ) {
4143 if( pr.y >= maxheight ) {
4144 // no space to print to anyway
4145 break;
4146 }
4147 if( listed_mons.count( type ) > 0 ) {
4148 // this type is already printed.
4149 continue;
4150 }
4151 listed_mons.insert( type );
4152
4153 const mtype &mt = *type;
4154 const std::string name = mt.nname();
4155
4156 // Move to the next row if necessary. (The +2 is for the "Z ").
4157 if( pr.x + 2 + utf8_width( name ) >= width ) {
4158 pr.y++;
4159 pr.x = hor_padding;
4160 }
4161
4162 if( pr.y < maxheight ) { // Don't print if we've overflowed
4163 mvwprintz( w, pr, mt.color, mt.sym );
4164 pr.x += 2; // symbol and space
4165 nc_color danger = c_dark_gray;
4166 if( mt.difficulty >= 30 ) {
4167 danger = c_red;
4168 } else if( mt.difficulty >= 16 ) {
4169 danger = c_light_red;
4170 } else if( mt.difficulty >= 8 ) {
4171 danger = c_white;
4172 } else if( mt.agro > 0 ) {
4173 danger = c_light_gray;
4174 }
4175 mvwprintz( w, pr, danger, name );
4176 pr.x += utf8_width( name ) + namesep;
4177 }
4178 }
4179 }
4180}
@ NPCATT_KILL
Definition: npc.h:91
@ NPCATT_FOLLOW
Definition: npc.h:84
std::vector< const mtype * > unique_mons[9]
Definition: avatar.h:47
bool dangerous[8]
Definition: avatar.h:50
std::vector< npc * > unique_types[9]
Definition: avatar.h:46
Definition: mtype.h:208
std::string sym
UTF-8 encoded symbol, should be exactly one cell wide.
Definition: mtype.h:253
nc_color color
Definition: mtype.h:258
int difficulty
Definition: mtype.h:264
int agro
e.g.
Definition: mtype.h:269

References _, mtype::agro, c, c_dark_gray, c_light_gray, c_light_green, c_light_red, c_pink, c_red, c_white, mtype::color, monster_visible_info::dangerous, mtype::difficulty, avatar::get_mon_visible(), catacurses::getmaxx(), catacurses::getmaxy(), mvwprintz(), om_direction::name(), mtype::nname(), NPCATT_FOLLOW, NPCATT_KILL, mtype::sym, type, u, monster_visible_info::unique_mons, monster_visible_info::unique_types, utf8_width(), point::x, and point::y.

◆ mon_info_update()

void game::mon_info_update ( )

Definition at line 4182 of file game.cpp.

4183{
4184 int newseen = 0;
4185 const int safe_proxy_dist = get_option<int>( "SAFEMODEPROXIMITY" );
4186 const int iProxyDist = ( safe_proxy_dist <= 0 ) ? MAX_VIEW_DISTANCE :
4187 safe_proxy_dist;
4188
4189 monster_visible_info &mon_visible = u.get_mon_visible();
4190 auto &new_seen_mon = mon_visible.new_seen_mon;
4191 auto &unique_types = mon_visible.unique_types;
4192 auto &unique_mons = mon_visible.unique_mons;
4193 auto &dangerous = mon_visible.dangerous;
4194
4195 // 7 0 1 unique_types uses these indices;
4196 // 6 8 2 0-7 are provide by direction_from()
4197 // 5 4 3 8 is used for local monsters (for when we explain them below)
4198 for( auto &t : unique_types ) {
4199 t.clear();
4200 }
4201 for( auto &m : unique_mons ) {
4202 m.clear();
4203 }
4204 std::fill( dangerous, dangerous + 8, false );
4205
4206 const tripoint view = u.pos() + u.view_offset;
4207 new_seen_mon.clear();
4208
4209 // TODO: no reason to have it static here
4210 static time_point previous_turn = calendar::start_of_cataclysm;
4211 const time_duration sm_ignored_time = time_duration::from_turns(
4212 get_option<int>( "SAFEMODEIGNORETURNS" ) );
4213
4215 monster *m = dynamic_cast<monster *>( c );
4216 npc *p = dynamic_cast<npc *>( c );
4217 const direction dir_to_mon = direction_from( view.xy(), point( c->posx(), c->posy() ) );
4218 const int mx = POSX + ( c->posx() - view.x );
4219 const int my = POSY + ( c->posy() - view.y );
4220 int index = 8;
4221 if( !is_valid_in_w_terrain( point( mx, my ) ) ) {
4222 // for compatibility with old code, see diagram below, it explains the values for index,
4223 // also might need revisiting one z-levels are in.
4224 switch( dir_to_mon ) {
4228 index = 7;
4229 break;
4231 case direction::NORTH:
4233 index = 0;
4234 break;
4238 index = 1;
4239 break;
4241 case direction::WEST:
4243 index = 6;
4244 break;
4246 case direction::CENTER:
4248 index = 8;
4249 break;
4251 case direction::EAST:
4253 index = 2;
4254 break;
4258 index = 5;
4259 break;
4261 case direction::SOUTH:
4263 index = 4;
4264 break;
4268 index = 3;
4269 break;
4270 }
4271 }
4272
4273 rule_state safemode_state = RULE_NONE;
4274 const bool safemode_empty = get_safemode().empty();
4275
4276 if( m != nullptr ) {
4277 //Safemode monster check
4278 monster &critter = *m;
4279
4280 const monster_attitude matt = critter.attitude( &u );
4281 const int mon_dist = rl_dist( u.pos(), critter.pos() );
4282 safemode_state = get_safemode().check_monster( critter.name(), critter.attitude_to( u ), mon_dist );
4283
4284 if( ( !safemode_empty && safemode_state == RULE_BLACKLISTED ) || ( safemode_empty &&
4285 ( MATT_ATTACK == matt || MATT_FOLLOW == matt ) ) ) {
4286 if( index < 8 && critter.sees( g->u ) ) {
4287 dangerous[index] = true;
4288 }
4289
4290 if( !safemode_empty || mon_dist <= iProxyDist ) {
4291 bool passmon = false;
4292 if( critter.ignoring > 0 ) {
4293 if( safe_mode != SAFE_MODE_ON ) {
4294 critter.ignoring = 0;
4295 } else if( ( sm_ignored_time == 0_seconds || ( critter.lastseen_turn &&
4296 *critter.lastseen_turn > calendar::turn - sm_ignored_time ) ) &&
4297 ( mon_dist > critter.ignoring / 2 || mon_dist < 6 ) ) {
4298 passmon = true;
4299 }
4300 critter.lastseen_turn = calendar::turn;
4301 }
4302
4303 if( !passmon ) {
4304 newseen++;
4305 new_seen_mon.push_back( shared_from( critter ) );
4306 }
4307 }
4308 }
4309
4310 std::vector<const mtype *> &vec = unique_mons[index];
4311 if( std::find( vec.begin(), vec.end(), critter.type ) == vec.end() ) {
4312 vec.push_back( critter.type );
4313 }
4314 } else if( p != nullptr ) {
4315 //Safe mode NPC check
4316
4317 const int npc_dist = rl_dist( u.pos(), p->pos() );
4318 safemode_state = get_safemode().check_monster( get_safemode().npc_type_name(), p->attitude_to( u ),
4319 npc_dist );
4320
4321 if( ( !safemode_empty && safemode_state == RULE_BLACKLISTED ) || ( safemode_empty &&
4322 p->get_attitude() == NPCATT_KILL ) ) {
4323 if( !safemode_empty || npc_dist <= iProxyDist ) {
4324 newseen++;
4325 }
4326 }
4327 unique_types[index].push_back( p );
4328 }
4329 }
4330
4331 if( newseen > mostseen ) {
4332 if( newseen - mostseen == 1 ) {
4333 if( !new_seen_mon.empty() ) {
4334 monster &critter = *new_seen_mon.back();
4336 string_format( _( "%s spotted!" ), critter.name() ) );
4337 if( u.has_trait( trait_id( "M_DEFENDER" ) ) && critter.type->in_species( PLANT ) ) {
4338 add_msg( m_warning, _( "We have detected a %s - an enemy of the Mycus!" ), critter.name() );
4340 u.add_effect( effect_adrenaline_mycus, 30_minutes );
4341 } else if( u.get_effect_int( effect_adrenaline_mycus ) == 1 ) {
4342 // Triffids present. We ain't got TIME to adrenaline comedown!
4343 u.add_effect( effect_adrenaline_mycus, 15_minutes );
4344 u.mod_pain( 3 ); // Does take it out of you, though
4345 add_msg( m_info, _( "Our fibers strain with renewed wrath!" ) );
4346 }
4347 }
4348 } else {
4349 //Hostile NPC
4351 _( "Hostile survivor spotted!" ) );
4352 }
4353 } else {
4355 }
4357 if( safe_mode == SAFE_MODE_ON ) {
4359 }
4360 } else if( calendar::turn > previous_turn && get_option<bool>( "AUTOSAFEMODE" ) &&
4361 newseen == 0 ) { // Auto-safe mode, but only if it's a new turn
4362 turnssincelastmon += to_turns<int>( calendar::turn - previous_turn );
4363 if( turnssincelastmon >= get_option<int>( "AUTOSAFEMODETURNS" ) && safe_mode == SAFE_MODE_OFF ) {
4365 add_msg( m_info, _( "Safe mode ON!" ) );
4366 }
4367 }
4368
4369 if( newseen == 0 && safe_mode == SAFE_MODE_STOP ) {
4371 }
4372
4373 previous_turn = calendar::turn;
4374 mostseen = newseen;
4375}
int get_effect_int(const efftype_id &eff_id, body_part bp=num_bp) const
Returns the intensity of the matching effect.
Definition: creature.cpp:1247
virtual bool sees(const Creature &critter) const
The functions check whether this creature can see the target.
Definition: creature.cpp:202
bool cancel_activity_or_ignore_query(distraction_type type, const std::string &text)
Asks if the player wants to cancel their activity and if so cancels it.
Definition: game.cpp:1792
monster_attitude attitude(const Character *u=nullptr) const
Definition: monster.cpp:1066
cata::optional< time_point > lastseen_turn
Definition: monster.h:506
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
Definition: npc.cpp:2074
rule_state check_monster(const std::string &creature_name_in, Creature::Attitude attitude_in, int proximity_in) const
bool empty() const
rule_state
Definition: enums.h:51
@ RULE_NONE
Definition: enums.h:52
bool is_valid_in_w_terrain(const point &p)
Definition: game.cpp:274
static const species_id PLANT("PLANT")
static const efftype_id effect_adrenaline_mycus("adrenaline_mycus")
static constexpr int MAPSIZE_X
monster_attitude
Definition: monster.h:54
@ MATT_FOLLOW
Definition: monster.h:60
@ MATT_ATTACK
Definition: monster.h:61
FMT_NOINLINE OutputIt fill(OutputIt it, size_t n, const fill_t< Char > &fill)
bool in_species(const species_id &spec) const
Definition: mtype.cpp:122

References _, ABOVECENTER, ABOVEEAST, ABOVENORTH, ABOVENORTHEAST, ABOVENORTHWEST, ABOVESOUTH, ABOVESOUTHEAST, ABOVESOUTHWEST, ABOVEWEST, Creature::add_effect(), add_msg(), monster::attitude(), monster::attitude_to(), npc::attitude_to(), BELOWCENTER, BELOWEAST, BELOWNORTH, BELOWNORTHEAST, BELOWNORTHWEST, BELOWSOUTH, BELOWSOUTHEAST, BELOWSOUTHWEST, BELOWWEST, c, cancel_activity_or_ignore_query(), CENTER, safemode::check_monster(), monster_visible_info::dangerous, direction_from(), EAST, effect_adrenaline_mycus, safemode::empty(), detail::fill(), detail::find(), time_duration::from_turns(), g, npc::get_attitude(), Creature::get_effect_int(), avatar::get_mon_visible(), get_safemode(), Character::get_visible_creatures(), Creature::has_effect(), Character::has_trait(), hostile_spotted_far, monster::ignoring, mtype::in_species(), is_valid_in_w_terrain(), monster::lastseen_turn, m, m_info, m_warning, MAPSIZE_X, MATT_ATTACK, MATT_FOLLOW, MAX_VIEW_DISTANCE, player::mod_pain(), mostseen, monster::name(), monster_visible_info::new_seen_mon, NORTH, NORTHEAST, NORTHWEST, NPCATT_KILL, PLANT, Character::pos(), monster::pos(), POSX, POSY, rl_dist(), RULE_BLACKLISTED, RULE_NONE, safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAFE_MODE_STOP, Creature::sees(), set_safe_mode(), shared_from(), SOUTH, SOUTHEAST, SOUTHWEST, calendar::start_of_cataclysm, string_format(), calendar::turn, turnssincelastmon, monster::type, u, monster_visible_info::unique_mons, monster_visible_info::unique_types, player::view_offset, WEST, tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by do_turn().

◆ monmove()

void game::monmove ( )
private

Definition at line 4412 of file game.cpp.

4413{
4414 cleanup_dead();
4415
4416 for( monster &critter : all_monsters() ) {
4417 // Critters in impassable tiles get pushed away, unless it's not impassable for them
4418 if( !critter.is_dead() && m.impassable( critter.pos() ) && !critter.can_move_to( critter.pos() ) ) {
4419 std::string msg = string_format( "%s can't move to its location! %s %s", critter.name(),
4420 critter.pos().to_string(), m.tername( critter.pos() ) );
4421 dbg( DL::Error ) << msg;
4422 add_msg( m_debug, msg );
4423 bool okay = false;
4424 for( const tripoint &dest : m.points_in_radius( critter.pos(), 3 ) ) {
4425 if( critter.can_move_to( dest ) && is_empty( dest ) ) {
4426 critter.setpos( dest );
4427 okay = true;
4428 break;
4429 }
4430 }
4431 if( !okay ) {
4432 // die of "natural" cause (overpopulation is natural)
4433 critter.die( nullptr );
4434 }
4435 }
4436
4437 if( !critter.is_dead() ) {
4438 critter.process_items();
4439 }
4440
4441 if( !critter.is_dead() ) {
4442 critter.process_turn();
4443 }
4444
4445 m.creature_in_field( critter );
4446 if( calendar::once_every( 1_days ) ) {
4447 if( critter.has_flag( MF_MILKABLE ) ) {
4448 critter.refill_udders();
4449 }
4450 critter.try_reproduce();
4451 }
4452 while( critter.moves > 0 && !critter.is_dead() && !critter.has_effect( effect_ridden ) ) {
4453 critter.made_footstep = false;
4454 // Controlled critters don't make their own plans
4455 if( !critter.has_effect( effect_ai_controlled ) ) {
4456 // Formulate a path to follow
4457 critter.plan();
4458 }
4459 critter.move(); // Move one square, possibly hit u
4460 critter.process_triggers();
4461 m.creature_in_field( critter );
4462 }
4463
4464 if( !critter.is_dead() &&
4465 u.has_active_bionic( bionic_id( "bio_alarm" ) ) &&
4466 u.get_power_level() >= 25_kJ &&
4467 rl_dist( u.pos(), critter.pos() ) <= 5 &&
4468 !critter.is_hallucination() ) {
4469 u.mod_power_level( -25_kJ );
4470 add_msg( m_warning, _( "Your motion alarm goes off!" ) );
4472 _( "Your motion alarm goes off!" ) );
4473 if( u.has_effect( efftype_id( "sleep" ) ) ) {
4474 u.wake_up();
4475 }
4476 }
4477 }
4478
4479 cleanup_dead();
4480
4481 // The remaining monsters are all alive, but may be outside of the reality bubble.
4482 // If so, despawn them. This is not the same as dying, they will be stored for later and the
4483 // monster::die function is not called.
4484 for( monster &critter : all_monsters() ) {
4485 if( critter.posx() < 0 - ( MAPSIZE_X ) / 6 ||
4486 critter.posy() < 0 - ( MAPSIZE_Y ) / 6 ||
4487 critter.posx() > ( MAPSIZE_X * 7 ) / 6 ||
4488 critter.posy() > ( MAPSIZE_Y * 7 ) / 6 ) {
4489 despawn_monster( critter );
4490 }
4491 }
4492
4493 // Now, do active NPCs.
4494 for( npc &guy : g->all_npcs() ) {
4495 int turns = 0;
4496 if( guy.is_mounted() ) {
4497 guy.check_mount_is_spooked();
4498 }
4499 m.creature_in_field( guy );
4500 if( !guy.has_effect( effect_npc_suspend ) ) {
4501 guy.process_turn();
4502 }
4503 while( !guy.is_dead() && guy.moves > 0 && turns < 10 &&
4504 ( !guy.in_sleep_state() || guy.activity.id() == ACT_OPERATION )
4505 ) {
4506 int moves = guy.moves;
4507 guy.move();
4508 if( moves == guy.moves ) {
4509 // Count every time we exit npc::move() without spending any moves.
4510 turns++;
4511 }
4512
4513 // Turn on debug mode when in infinite loop
4514 // It has to be done before the last turn, otherwise
4515 // there will be no meaningful debug output.
4516 if( turns == 9 ) {
4517 debugmsg( "NPC %s entered infinite loop. Turning on debug mode",
4518 guy.name );
4519 debug_mode = true;
4520 }
4521 }
4522
4523 // If we spun too long trying to decide what to do (without spending moves),
4524 // Invoke cognitive suspension to prevent an infinite loop.
4525 if( turns == 10 ) {
4526 add_msg( _( "%s faints!" ), guy.name );
4527 guy.reboot();
4528 }
4529
4530 if( !guy.is_dead() ) {
4531 guy.npc_update_body();
4532 }
4533 }
4534 cleanup_dead();
4535}
void mod_power_level(const units::energy &npower)
Definition: character.cpp:1990
units::energy get_power_level() const
Definition: character.cpp:1970
void wake_up()
Definition: avatar.cpp:950
static const activity_id ACT_OPERATION("ACT_OPERATION")
static const efftype_id effect_npc_suspend("npc_suspend")
static const efftype_id effect_ai_controlled("ai_controlled")
static constexpr int MAPSIZE_Y
@ MF_MILKABLE
Definition: mtype.h:167

References _, ACT_OPERATION, add_msg(), all_monsters(), cancel_activity_or_ignore_query(), cleanup_dead(), map::creature_in_field(), dbg, debug_mode, debugmsg, despawn_monster(), effect_ai_controlled, effect_npc_suspend, effect_ridden, Error, g, Character::get_power_level(), Character::has_active_bionic(), Creature::has_effect(), map::impassable(), is_empty(), m, m_debug, m_warning, MAPSIZE_X, MAPSIZE_Y, MF_MILKABLE, Character::mod_power_level(), motion_alarm, calendar::once_every(), map::points_in_radius(), Character::pos(), rl_dist(), string_format(), map::tername(), u, and avatar::wake_up().

Referenced by do_turn().

◆ mouse_edge_scrolling()

std::pair< tripoint, tripoint > game::mouse_edge_scrolling ( input_context ctxt,
int  speed,
const tripoint last,
bool  iso 
)
private

Definition at line 2354 of file game.cpp.

2356{
2357 const int rate = get_option<int>( "EDGE_SCROLL" );
2358 auto ret = std::make_pair( tripoint_zero, last );
2359 if( rate == -1 ) {
2360 // Fast return when the option is disabled.
2361 return ret;
2362 }
2363 // Ensure the parameters are used even if the #if below is false
2364 ( void ) ctxt;
2365 ( void ) speed;
2366 ( void ) iso;
2367#if (defined TILES || defined _WIN32 || defined WINDOWS)
2368 auto now = std::chrono::steady_clock::now();
2369 if( now < last_mouse_edge_scroll + std::chrono::milliseconds( rate ) ) {
2370 return ret;
2371 } else {
2373 }
2374 const input_event event = ctxt.get_raw_input();
2375 if( event.type == CATA_INPUT_MOUSE ) {
2376 const point threshold( projected_window_width() / 100, projected_window_height() / 100 );
2377 if( event.mouse_pos.x <= threshold.x ) {
2378 ret.first.x -= speed;
2379 if( iso ) {
2380 ret.first.y -= speed;
2381 }
2382 } else if( event.mouse_pos.x >= projected_window_width() - threshold.x ) {
2383 ret.first.x += speed;
2384 if( iso ) {
2385 ret.first.y += speed;
2386 }
2387 }
2388 if( event.mouse_pos.y <= threshold.y ) {
2389 ret.first.y -= speed;
2390 if( iso ) {
2391 ret.first.x += speed;
2392 }
2393 } else if( event.mouse_pos.y >= projected_window_height() - threshold.y ) {
2394 ret.first.y += speed;
2395 if( iso ) {
2396 ret.first.x -= speed;
2397 }
2398 }
2399 ret.second = ret.first;
2400 } else if( event.type == CATA_INPUT_TIMEOUT ) {
2401 ret.first = ret.second;
2402 }
2403#endif
2404 return ret;
2405}
@ CATA_INPUT_TIMEOUT
Definition: input.h:81
@ CATA_INPUT_MOUSE
Definition: input.h:84

References CATA_INPUT_MOUSE, CATA_INPUT_TIMEOUT, input_context::get_raw_input(), iso, last, last_mouse_edge_scroll, cata::hash64_detail::ret, tripoint_zero, point::x, and point::y.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ mouse_edge_scrolling_overmap()

tripoint game::mouse_edge_scrolling_overmap ( input_context ctxt)

This variant is suitable for the overmap.

Definition at line 2416 of file game.cpp.

2417{
2418 // overmap has no iso mode
2422 return ret.first;
2423}
std::pair< tripoint, tripoint > mouse_edge_scrolling(input_context &ctxt, int speed, const tripoint &last, bool iso)
Definition: game.cpp:2354
tripoint last_mouse_edge_scroll_vector_terrain
Definition: game.h:1117
tripoint last_mouse_edge_scroll_vector_overmap
Definition: game.h:1118

References last_mouse_edge_scroll_vector_overmap, last_mouse_edge_scroll_vector_terrain, mouse_edge_scrolling(), cata::hash64_detail::ret, and tripoint_zero.

◆ mouse_edge_scrolling_terrain()

tripoint game::mouse_edge_scrolling_terrain ( input_context ctxt)

Used to implement mouse "edge scrolling".

Returns a tripoint which is a vector of the resulting "move", i.e. (0, 0, 0) if the mouse is not at the edge of the screen, otherwise some (x, y, 0) depending on which edges are hit. This variant adjust scrolling speed according to zoom level, making it suitable when viewing the "terrain".

Definition at line 2407 of file game.cpp.

References DEFAULT_TILESET_ZOOM, last_mouse_edge_scroll_vector_overmap, last_mouse_edge_scroll_vector_terrain, mouse_edge_scrolling(), cata::hash64_detail::ret, tile_iso, tileset_zoom, and tripoint_zero.

Referenced by look_around().

◆ move_save_to_graveyard()

void game::move_save_to_graveyard ( const std::string &  dirname)
private

Definition at line 2788 of file game.cpp.

2789{
2790 const std::string save_dir = get_world_base_save_path();
2791 const std::string graveyard_dir = PATH_INFO::graveyarddir() + "/";
2792 const std::string graveyard_save_dir = graveyard_dir + dirname + "/";
2793 const std::string prefix = base64_encode( u.name ) + ".";
2794
2795 if( !assure_dir_exist( graveyard_dir ) ) {
2796 debugmsg( "could not create graveyard path '%s'", graveyard_dir );
2797 }
2798
2799 if( !assure_dir_exist( graveyard_save_dir ) ) {
2800 debugmsg( "could not create graveyard path '%s'", graveyard_save_dir );
2801 }
2802
2803 const auto save_files = get_files_from_path( prefix, save_dir );
2804 if( save_files.empty() ) {
2805 debugmsg( "could not find save files in '%s'", save_dir );
2806 }
2807
2808 for( const auto &src_path : save_files ) {
2809 const std::string dst_path = graveyard_save_dir +
2810 src_path.substr( src_path.rfind( '/' ), std::string::npos );
2811
2812 if( rename_file( src_path, dst_path ) ) {
2813 continue;
2814 }
2815
2816 debugmsg( "could not rename file '%s' to '%s'", src_path, dst_path );
2817
2818 if( remove_file( src_path ) ) {
2819 continue;
2820 }
2821
2822 debugmsg( "could not remove file '%s'", src_path );
2823 }
2824}
@ prefix
Definition: enums.h:79
bool remove_file(const std::string &path)
Remove a file.
Definition: filesystem.cpp:89
bool assure_dir_exist(const std::string &path)
Create directory if it does not exist.
Definition: filesystem.cpp:48
bool rename_file(const std::string &old_path, const std::string &new_path)
Rename a file, overwriting the target.
Definition: filesystem.cpp:105
std::vector< std::string > get_files_from_path(const std::string &pattern, const std::string &root_path, const bool recursive_search, const bool match_extension)
Returns a vector of files or directories matching pattern at root_path.
Definition: filesystem.cpp:362
std::string graveyarddir()
Definition: path_info.cpp:202

References assure_dir_exist(), base64_encode(), debugmsg, get_files_from_path(), get_world_base_save_path(), PATH_INFO::graveyarddir(), Character::name, prefix, remove_file(), rename_file(), and u.

Referenced by cleanup_at_end().

◆ moving_vehicle_dismount()

void game::moving_vehicle_dismount ( const tripoint dest_loc)

Handles players exiting from moving vehicles.

Definition at line 5426 of file game.cpp.

5427{
5428 const optional_vpart_position vp = m.veh_at( u.pos() );
5429 if( !vp ) {
5430 debugmsg( "Tried to exit non-existent vehicle." );
5431 return;
5432 }
5433 vehicle *const veh = &vp->vehicle();
5434 if( u.pos() == dest_loc ) {
5435 debugmsg( "Need somewhere to dismount towards." );
5436 return;
5437 }
5438 tileray ray( dest_loc.xy() + point( -u.posx(), -u.posy() ) );
5439 // TODO:: make dir() const correct!
5440 const units::angle d = ray.dir();
5441 add_msg( _( "You dive from the %s." ), veh->name );
5442 m.unboard_vehicle( u.pos() );
5443 u.moves -= 200;
5444 // Dive three tiles in the direction of tox and toy
5445 fling_creature( &u, d, 30, true );
5446 // Hit the ground according to vehicle speed
5447 if( !m.has_flag( "SWIMMABLE", u.pos() ) ) {
5448 if( veh->velocity > 0 ) {
5449 fling_creature( &u, veh->face.dir(), veh->velocity / static_cast<float>( 100 ) );
5450 } else {
5451 fling_creature( &u, veh->face.dir() + 180_degrees,
5452 -( veh->velocity ) / static_cast<float>( 100 ) );
5453 }
5454 }
5455}
void fling_creature(Creature *c, const units::angle &dir, float flvel, bool controlled=false, bool suppress_map_update=false)
Flings the input creature in the given direction.
Definition: game.cpp:10316

References _, add_msg(), debugmsg, tileray::dir(), vehicle::face, fling_creature(), map::has_flag(), m, Creature::moves, vehicle::name, Character::pos(), Character::posx(), Character::posy(), u, map::unboard_vehicle(), map::veh_at(), vehicle::velocity, and tripoint::xy().

◆ natural_light_level()

float game::natural_light_level ( int  zlev) const

Definition at line 3869 of file game.cpp.

3870{
3871 // ignore while underground or above limits
3872 if( zlev > OVERMAP_HEIGHT || zlev < 0 ) {
3873 return LIGHT_AMBIENT_MINIMAL;
3874 }
3875
3876 if( latest_lightlevels[zlev] > -std::numeric_limits<float>::max() ) {
3877 // Already found the light level for now?
3878 return latest_lightlevels[zlev];
3879 }
3880
3881 float ret = LIGHT_AMBIENT_MINIMAL;
3882
3883 // Sunlight/moonlight related stuff
3885 if( !weather.lightning_active ) {
3887 } else {
3888 // Recent lightning strike has lit the area
3890 }
3891
3893
3894 // Artifact light level changes here. Even though some of these only have an effect
3895 // aboveground it is cheaper performance wise to simply iterate through the entire
3896 // list once instead of twice.
3897 float mod_ret = -1;
3898 // Each artifact change does std::max(mod_ret, new val) since a brighter end value
3899 // will trump a lower one.
3900 if( const timed_event *e = timed_events.get( TIMED_EVENT_DIM ) ) {
3901 // TIMED_EVENT_DIM slowly dims the natural sky level, then relights it.
3902 const time_duration left = e->when - calendar::turn;
3903 // TIMED_EVENT_DIM has an occurrence date of turn + 50, so the first 25 dim it,
3904 if( left > 25_turns ) {
3905 mod_ret = std::max( static_cast<double>( mod_ret ), ( ret * ( left - 25_turns ) ) / 25_turns );
3906 // and the last 25 scale back towards normal.
3907 } else {
3908 mod_ret = std::max( static_cast<double>( mod_ret ), ( ret * ( 25_turns - left ) ) / 25_turns );
3909 }
3910 }
3912 // TIMED_EVENT_ARTIFACT_LIGHT causes everywhere to become as bright as day.
3913 mod_ret = std::max<float>( ret, default_daylight_level() );
3914 }
3915 // If we had a changed light level due to an artifact event then it overwrites
3916 // the natural light level.
3917 if( mod_ret > -1 ) {
3918 ret = mod_ret;
3919 }
3920
3921 // Cap everything to our minimum light level
3922 ret = std::max<float>( LIGHT_AMBIENT_MINIMAL, ret );
3923
3924 latest_lightlevels[zlev] = ret;
3925
3926 return ret;
3927}
double default_daylight_level()
How much light is provided in full daylight.
Definition: calendar.cpp:62
float sunlight(const time_point &p, const bool vision)
Returns the current sunlight or moonlight level through the preceding functions.
Definition: calendar.cpp:199
std::array< float, OVERMAP_LAYERS > latest_lightlevels
Definition: game.h:1090
bool queued(timed_event_type type) const
timed_event * get(timed_event_type type)
weather_type_id weather_id
Definition: weather.h:193
static constexpr float LIGHT_AMBIENT_MINIMAL
Definition: lightmap.h:12
@ TIMED_EVENT_DIM
Definition: timed_event.h:22
@ TIMED_EVENT_ARTIFACT_LIGHT
Definition: timed_event.h:23

References default_daylight_level(), timed_event_manager::get(), get_weather, latest_lightlevels, left, LIGHT_AMBIENT_MINIMAL, weather_type::light_modifier, OVERMAP_HEIGHT, timed_event_manager::queued(), cata::hash64_detail::ret, sunlight(), TIMED_EVENT_ARTIFACT_LIGHT, TIMED_EVENT_DIM, timed_events, calendar::turn, and weather_manager::weather_id.

Referenced by light_level().

◆ npc_menu()

bool game::npc_menu ( npc who)

Returns true if the menu handled stuff and player shouldn't do anything else.

Perception slightly increases precision when examining NPCs' wounds Firstaid increases precision when examining NPCs' wounds

Definition at line 5557 of file game.cpp.

5558{
5559 enum choices : int {
5560 talk = 0,
5561 swap_pos,
5562 push,
5563 examine_wounds,
5564 use_item,
5565 sort_armor,
5566 attack,
5567 disarm,
5568 steal
5569 };
5570
5571 const bool obeys = debug_mode || ( who.is_player_ally() && !who.in_sleep_state() );
5572
5573 uilist amenu;
5574
5575 amenu.text = string_format( _( "What to do with %s?" ), who.disp_name() );
5576 amenu.addentry( talk, true, 't', _( "Talk" ) );
5577 amenu.addentry( swap_pos, obeys && !who.is_mounted() &&
5578 !u.is_mounted(), 's', _( "Swap positions" ) );
5579 amenu.addentry( push, obeys && !who.is_mounted(), 'p', _( "Push away" ) );
5580 amenu.addentry( examine_wounds, true, 'w', _( "Examine wounds" ) );
5581 amenu.addentry( use_item, true, 'i', _( "Use item on" ) );
5582 amenu.addentry( sort_armor, true, 'r', _( "Sort armor" ) );
5583 amenu.addentry( attack, true, 'a', _( "Attack" ) );
5584 if( !who.is_player_ally() ) {
5585 amenu.addentry( disarm, who.is_armed(), 'd', _( "Disarm" ) );
5586 amenu.addentry( steal, !who.is_enemy(), 'S', _( "Steal" ) );
5587 }
5588
5589 amenu.query();
5590
5591 const int choice = amenu.ret;
5592 if( choice == talk ) {
5593 who.talk_to_u();
5594 } else if( choice == swap_pos ) {
5595 if( !prompt_dangerous_tile( who.pos() ) ) {
5596 return true;
5597 }
5598 // TODO: Make NPCs protest when displaced onto dangerous crap
5599 add_msg( _( "You swap places with %s." ), who.name );
5600 swap_critters( u, who );
5601 // TODO: Make that depend on stuff
5602 u.mod_moves( -200 );
5603 } else if( choice == push ) {
5604 // TODO: Make NPCs protest when displaced onto dangerous crap
5605 tripoint oldpos = who.pos();
5606 who.move_away_from( u.pos(), true );
5607 u.mod_moves( -20 );
5608 if( oldpos != who.pos() ) {
5609 add_msg( _( "%s moves out of the way." ), who.name );
5610 } else {
5611 add_msg( m_warning, _( "%s has nowhere to go!" ), who.name );
5612 }
5613 } else if( choice == examine_wounds ) {
5614 ///\EFFECT_PER slightly increases precision when examining NPCs' wounds
5615
5616 ///\EFFECT_FIRSTAID increases precision when examining NPCs' wounds
5617 const bool precise = u.get_skill_level( skill_firstaid ) * 4 + u.per_cur >= 20;
5618 who.body_window( _( "Limbs of: " ) + who.disp_name(), true, precise, 0, 0, 0, 0.0f, 0.0f, 0.0f,
5619 0.0f, 0.0f );
5620 } else if( choice == use_item ) {
5621 static const std::string heal_string( "heal" );
5622 const auto will_accept = []( const item & it ) {
5623 const auto use_fun = it.get_use( heal_string );
5624 if( use_fun == nullptr ) {
5625 return false;
5626 }
5627
5628 const auto *actor = dynamic_cast<const heal_actor *>( use_fun->get_actor_ptr() );
5629
5630 return actor != nullptr &&
5631 actor->limb_power >= 0 &&
5632 actor->head_power >= 0 &&
5633 actor->torso_power >= 0;
5634 };
5635 item_location loc = game_menus::inv::titled_filter_menu( will_accept, u, _( "Use which item?" ) );
5636
5637 if( !loc ) {
5638 add_msg( _( "Never mind" ) );
5639 return false;
5640 }
5641 item &used = *loc;
5642 bool did_use = u.invoke_item( &used, heal_string, who.pos() );
5643 if( did_use ) {
5644 // Note: exiting a body part selection menu counts as use here
5645 u.mod_moves( -300 );
5646 }
5647 } else if( choice == sort_armor ) {
5648 who.sort_armor();
5649 u.mod_moves( -100 );
5650 } else if( choice == attack ) {
5651 if( who.is_enemy() || query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5652 u.melee_attack( who, true );
5653 who.on_attacked( u );
5654 }
5655 } else if( choice == disarm ) {
5656 if( who.is_enemy() || query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5657 u.disarm( who );
5658 }
5659 } else if( choice == steal && query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5660 u.steal( who );
5661 }
5662
5663 return true;
5664}
hp_part body_window(const std::string &menu_header, bool show_all, bool precise, int normal_bonus, int head_bonus, int torso_bonus, float bleed, float bite, float infect, float bandage_power, float disinfectant_power) const
Displays menu with body part hp, optionally with hp estimation after healing.
Definition: character.cpp:5863
bool in_sleep_state() const override
Definition: character.cpp:9334
void melee_attack(Creature &t, bool allow_special, const matec_id &force_technique, bool allow_unarmed=true)
Sets up a melee attack and handles melee attack function calls.
Definition: melee.cpp:390
int per_cur
Definition: character.h:249
void steal(npc &target)
Try to steal an item from the NPC's inventory.
Definition: melee.cpp:2340
bool prompt_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:9256
bool swap_critters(Creature &, Creature &)
Swaps positions of two creatures.
Definition: game.cpp:5083
float limb_power
How much hp to restore when healing limbs?
Definition: iuse_actor.h:1011
void talk_to_u(bool radio_contact=false)
Definition: npctalk.cpp:731
void on_attacked(const Creature &attacker)
Definition: npc.cpp:1446
void move_away_from(const tripoint &p, bool no_bash_atk=false, std::set< tripoint > *nomove=nullptr)
Definition: npcmove.cpp:2516
void disarm(npc &target)
Try to disarm the NPC.
Definition: melee.cpp:2264
static const skill_id skill_firstaid("firstaid")
static void swap_pos(Creature &caster, const tripoint &target)
item_location steal(avatar &you, player &victim)
Menu for stealing stuff.
item_location titled_filter_menu(item_filter filter, avatar &you, const std::string &title, const std::string &none_message="")
void push(monster &z)
Definition: monexamine.cpp:552

References _, add_msg(), uilist::addentry(), Character::body_window(), debug_mode, player::disarm(), Character::disp_name(), Character::get_skill_level(), Character::in_sleep_state(), avatar::invoke_item(), Character::is_armed(), npc::is_enemy(), Character::is_mounted(), npc::is_player_ally(), heal_actor::limb_power, m_warning, Character::melee_attack(), Creature::mod_moves(), npc::move_away_from(), Character::name, npc::on_attacked(), Character::per_cur, Character::pos(), prompt_dangerous_tile(), monexamine::push(), uilist::query(), query_yn(), uilist::ret, skill_firstaid, player::sort_armor(), game_menus::inv::steal(), avatar::steal(), string_format(), swap_critters(), swap_pos(), npc::talk_to_u(), uilist::text, game_menus::inv::titled_filter_menu(), u, and avatar_action::use_item().

Referenced by examine().

◆ num_creatures()

size_t game::num_creatures ( ) const

Returns the approximate number of creatures in the reality bubble.

Because of performance restrictions it may return a slightly incorrect values (as it includes dead, but not yet cleaned up creatures).

Definition at line 5028 of file game.cpp.

5029{
5030 return critter_tracker->size() + active_npc.size() + 1; // 1 == g->u
5031}

References active_npc, and critter_tracker.

Referenced by display_visibility(), and fungal_effects::fungalize().

◆ on_move_effects()

void game::on_move_effects ( )

Definition at line 10274 of file game.cpp.

10275{
10276 // TODO: Move this to a character method
10277 if( !u.is_mounted() ) {
10278 const item muscle( "muscle" );
10279 for( const bionic_id &bid : u.get_bionic_fueled_with( muscle ) ) {
10280 if( u.has_active_bionic( bid ) ) {// active power gen
10281 u.mod_power_level( units::from_kilojoule( muscle.fuel_energy() ) * bid->fuel_efficiency );
10282 } else if( u.has_bionic( bid ) ) {// passive power gen
10283 u.mod_power_level( units::from_kilojoule( muscle.fuel_energy() ) * bid->passive_fuel_efficiency );
10284 }
10285 }
10286
10287 if( u.has_active_bionic( bionic_id( "bio_jointservo" ) ) ) {
10288 if( u.movement_mode_is( CMM_RUN ) ) {
10289 u.mod_power_level( -55_J );
10290 } else {
10291 u.mod_power_level( -35_J );
10292 }
10293 }
10294 }
10295
10296 if( u.movement_mode_is( CMM_RUN ) ) {
10297 if( !u.can_run() ) {
10299 }
10300 }
10301
10302 // apply martial art move bonuses
10303 u.martial_arts_data->ma_onmove_effects( u );
10304
10306}
@ CMM_RUN
Definition: character.h:102
bool can_run()
source of truth of whether a Character can run
Definition: character.cpp:1332
bool movement_mode_is(character_movemode mode) const
Check against the character's current movement mode.
Definition: character.cpp:1622
std::vector< bionic_id > get_bionic_fueled_with(const item &it) const
Return bionic_id of bionics able to use it as fuel.
Definition: character.cpp:1931
bool has_bionic(const bionic_id &b) const
Returns true if the player has the entered bionic id.
Definition: character.cpp:1880
void do_ambient()
Definition: sounds.cpp:1616
constexpr quantity< value_type, energy_in_joule_tag > from_kilojoule(const value_type v)
Definition: units_energy.h:32

References Character::can_run(), CMM_RUN, sfx::do_ambient(), units::from_kilojoule(), item::fuel_energy(), Character::get_bionic_fueled_with(), Character::has_active_bionic(), Character::has_bionic(), Character::is_mounted(), Character::martial_arts_data, Character::mod_power_level(), Character::movement_mode_is(), avatar::toggle_run_mode(), and u.

Referenced by phasing_move(), and walk_move().

◆ on_options_changed()

void game::on_options_changed ( )

Should be invoked whenever options change.

Definition at line 10308 of file game.cpp.

10309{
10310#if defined(TILES)
10311 tilecontext->on_options_changed();
10312#endif
10313 grid_tracker_ptr->on_options_changed();
10314}

References grid_tracker_ptr.

◆ open_consume_item_menu()

void game::open_consume_item_menu ( )
private

Definition at line 1487 of file handle_action.cpp.

1488{
1489 uilist as_m;
1490
1491 as_m.text = _( "What do you want to consume?" );
1492
1493 as_m.entries.emplace_back( 0, true, 'f', _( "Food" ) );
1494 as_m.entries.emplace_back( 1, true, 'd', _( "Drink" ) );
1495 as_m.entries.emplace_back( 2, true, 'm', _( "Medication" ) );
1496 as_m.query();
1497
1498 switch( as_m.ret ) {
1499 case 0:
1501 break;
1502 case 1:
1504 break;
1505 case 2:
1507 break;
1508 default:
1509 break;
1510 }
1511}
item_location consume_drink(player &p)
Consuming a drink item via a custom menu.
item_location consume_meds(player &p)
Consuming a medication item via a custom menu.
item_location consume_food(player &p)
Consuming a food item via a custom menu.

References _, game_menus::inv::consume_drink(), game_menus::inv::consume_food(), game_menus::inv::consume_meds(), avatar_action::eat(), uilist::entries, uilist::query(), uilist::ret, uilist::text, and u.

Referenced by handle_action().

◆ open_gate()

void game::open_gate ( const tripoint p)

Definition at line 5421 of file game.cpp.

5422{
5423 gates::open_gate( p, u );
5424}
void open_gate(const tripoint &pos, player &p)
opens the gate via player's activity
Definition: gates.cpp:236

References gates::open_gate(), and u.

◆ overmap_npc_move()

void game::overmap_npc_move ( )
private

Definition at line 4537 of file game.cpp.

4538{
4539 std::vector<npc *> travelling_npcs;
4540 static constexpr int move_search_radius = 600;
4541 for( auto &elem : overmap_buffer.get_npcs_near_player( move_search_radius ) ) {
4542 if( !elem ) {
4543 continue;
4544 }
4545 npc *npc_to_add = elem.get();
4546 if( ( !npc_to_add->is_active() || rl_dist( u.pos(), npc_to_add->pos() ) > SEEX * 2 ) &&
4547 npc_to_add->mission == NPC_MISSION_TRAVELLING ) {
4548 travelling_npcs.push_back( npc_to_add );
4549 }
4550 }
4551 for( auto &elem : travelling_npcs ) {
4552 if( elem->has_omt_destination() ) {
4553 if( !elem->omt_path.empty() && rl_dist( elem->omt_path.back(), elem->global_omt_location() ) > 2 ) {
4554 //recalculate path, we got distracted doing something else probably
4555 elem->omt_path.clear();
4556 }
4557 if( elem->omt_path.empty() ) {
4558 const tripoint_abs_omt &from = elem->global_omt_location();
4559 const tripoint_abs_omt &to = elem->goal;
4560 elem->omt_path = overmap_buffer.get_travel_path( elem->global_omt_location(), elem->goal,
4562 if( elem->omt_path.empty() ) {
4563 add_msg( m_debug, "%s couldn't find overmap path from %s to %s",
4564 elem->get_name(), from.to_string(), to.to_string() );
4565 elem->goal = npc::no_goal_point;
4566 elem->mission = NPC_MISSION_NULL;
4567 }
4568 } else {
4569 if( elem->omt_path.back() == elem->global_omt_location() ) {
4570 elem->omt_path.pop_back();
4571 }
4572 // TODO: fix point types
4573 elem->travel_overmap(
4574 project_to<coords::sm>( elem->omt_path.back() ).raw() );
4575 }
4576 reload_npcs();
4577 }
4578 }
4579 return;
4580}
std::vector< tripoint_abs_omt > omt_path
Definition: character.h:972
static constexpr tripoint_abs_omt no_goal_point
Definition: npc.h:1338
bool is_active() const
Definition: npc.cpp:2192
std::vector< tripoint_abs_omt > get_travel_path(const tripoint_abs_omt &src, const tripoint_abs_omt &dest, overmap_path_params params)
@ NPC_MISSION_NULL
Definition: npc.h:179
@ NPC_MISSION_TRAVELLING
Definition: npc.h:191
static overmap_path_params for_npc()

References add_msg(), overmap_path_params::for_npc(), overmapbuffer::get_npcs_near_player(), overmapbuffer::get_travel_path(), npc::is_active(), m_debug, npc::mission, npc::no_goal_point, NPC_MISSION_NULL, NPC_MISSION_TRAVELLING, Character::omt_path, overmap_buffer, Character::pos(), reload_npcs(), rl_dist(), SEEX, coords::coord_point< Point, Origin, Scale >::to_string(), and u.

Referenced by do_turn().

◆ peek() [1/2]

void game::peek ( )

Definition at line 5916 of file game.cpp.

5917{
5918 const cata::optional<tripoint> p = choose_direction( _( "Peek where?" ), true );
5919 if( !p ) {
5920 return;
5921 }
5922
5923 if( p->z != 0 ) {
5924 const tripoint old_pos = u.pos();
5925 vertical_move( p->z, false, true );
5926
5927 if( old_pos != u.pos() ) {
5928 look_around();
5929 vertical_move( p->z * -1, false, true );
5930 }
5931 return;
5932 }
5933
5934 if( m.impassable( u.pos() + *p ) ) {
5935 return;
5936 }
5937
5938 peek( u.pos() + *p );
5939}
cata::optional< tripoint > choose_direction(const std::string &message, const bool allow_vertical)
Request player input of a direction, possibly including vertical component.
Definition: action.cpp:971

References _, choose_direction(), map::impassable(), look_around(), m, peek(), Character::pos(), u, and vertical_move().

Referenced by handle_action(), and peek().

◆ peek() [2/2]

void game::peek ( const tripoint p)

Definition at line 5941 of file game.cpp.

5942{
5943 u.moves -= 200;
5944 tripoint prev = u.pos();
5945 u.setpos( p );
5946 tripoint center = p;
5947 const look_around_result result = look_around( /*show_window=*/true, center, center, false, false,
5948 true );
5949 u.setpos( prev );
5950
5951 if( result.peek_action && *result.peek_action == PA_BLIND_THROW ) {
5952 item_location loc;
5953 avatar_action::plthrow( u, loc, p );
5954 }
5956}

References center, map::invalidate_map_cache(), look_around(), m, Creature::moves, PA_BLIND_THROW, avatar_action::plthrow(), Character::pos(), Character::setpos(), u, and tripoint::z.

◆ perhaps_add_random_npc()

void game::perhaps_add_random_npc ( )
private

Definition at line 11582 of file game.cpp.

11583{
11584 if( !calendar::once_every( 1_hours ) ) {
11585 return;
11586 }
11587 // Create a new NPC?
11588 // Only allow NPCs on 0 z-level, otherwise they can bug out due to lack of spots
11589 if( !get_option<bool>( "RANDOM_NPC" ) || ( !m.has_zlevels() && get_levz() != 0 ) ) {
11590 return;
11591 }
11592
11593 float density = get_option<float>( "NPC_DENSITY" );
11594 static constexpr int density_search_radius = 60;
11595 const float npc_num = overmap_buffer.get_npcs_near_player( density_search_radius ).size();
11596 if( npc_num > 0.0 ) {
11597 // 100%, 80%, 64%, 52%, 41%, 33%...
11598 density *= std::pow( 0.8f, npc_num );
11599 }
11600
11601 if( !x_in_y( density, 100 ) ) {
11602 return;
11603 }
11604 bool spawn_allowed = false;
11606 int counter = 0;
11607 while( !spawn_allowed ) {
11608 if( counter >= 10 ) {
11609 return;
11610 }
11611 static constexpr int radius_spawn_range = 120;
11612 const tripoint_abs_omt u_omt = u.global_omt_location();
11613 spawn_point = u_omt + point( rng( -radius_spawn_range, radius_spawn_range ),
11614 rng( -radius_spawn_range, radius_spawn_range ) );
11615 spawn_point.z() = 0;
11616 const oter_id oter = overmap_buffer.ter( spawn_point );
11617 // shouldn't spawn on lakes or rivers.
11618 if( !is_river_or_lake( oter ) ) {
11619 spawn_allowed = true;
11620 }
11621 counter += 1;
11622 }
11623 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
11624 tmp->normalize();
11625 tmp->randomize();
11626 std::string new_fac_id = "solo_";
11627 new_fac_id += tmp->name;
11628 // create a new "lone wolf" faction for this one NPC
11629 faction *new_solo_fac = faction_manager_ptr->add_new_faction( tmp->name, faction_id( new_fac_id ),
11630 faction_id( "no_faction" ) );
11631 tmp->set_fac( new_solo_fac ? new_solo_fac->id : faction_id( "no_faction" ) );
11632 // adds the npc to the correct overmap.
11633 // Only spawn random NPCs on z-level 0
11634 // TODO: fix point types
11635 tripoint submap_spawn = omt_to_sm_copy( spawn_point.raw() );
11636 tmp->spawn_at_sm( tripoint( submap_spawn.xy(), 0 ) );
11638 tmp->form_opinion( u );
11639 tmp->mission = NPC_MISSION_NULL;
11640 tmp->long_term_goal_action();
11641 tmp->add_new_mission( mission::reserve_random( ORIGIN_ANY_NPC, tmp->global_omt_location(),
11642 tmp->getID() ) );
11643 // This will make the new NPC active- if its nearby to the player
11644 load_npcs();
11645}
faction_id id
Definition: faction.h:82
point omt_to_sm_copy(const point &p)
@ ORIGIN_ANY_NPC
Definition: mission.h:46
bool is_river_or_lake(const oter_id &ter)
Definition: overmap.cpp:563

References faction_manager_ptr, get_levz(), overmapbuffer::get_npcs_near_player(), Character::global_omt_location(), map::has_zlevels(), faction_template::id, overmapbuffer::insert_npc(), is_river_or_lake(), load_npcs(), m, NPC_MISSION_NULL, omt_to_sm_copy(), calendar::once_every(), ORIGIN_ANY_NPC, overmap_buffer, mission::reserve_random(), rng(), overmapbuffer::ter(), u, x_in_y(), and tripoint::xy().

Referenced by do_turn().

◆ phasing_move()

bool game::phasing_move ( const tripoint dest,
bool  via_ramp = false 
)

Definition at line 10006 of file game.cpp.

10007{
10008 if( dest_loc.z != u.posz() && !via_ramp ) {
10009 // No vertical phasing yet
10010 return false;
10011 }
10012
10013 //probability travel through walls but not water
10014 tripoint dest = dest_loc;
10015 // tile is impassable
10016 int tunneldist = 0;
10017 const point d( sgn( dest.x - u.posx() ), sgn( dest.y - u.posy() ) );
10018 while( m.impassable( dest ) ||
10019 ( critter_at( dest ) != nullptr && tunneldist > 0 ) ) {
10020 //add 1 to tunnel distance for each impassable tile in the line
10021 tunneldist += 1;
10022 //Being dimensionally anchored prevents quantum shenanigans.
10023 if( u.worn_with_flag( "DIMENSIONAL_ANCHOR" ) || u.has_effect_with_flag( "DIMENSIONAL_ANCHOR" ) ) {
10025 _( "You try to quantum tunnel through the barrier, but something holds you back!" ) );
10026 return false;
10027 }
10028
10029 if( tunneldist > 24 ) {
10030 add_msg( m_info, _( "It's too dangerous to tunnel that far!" ) );
10031 return false;
10032 }
10033
10034 dest.x += d.x;
10035 dest.y += d.y;
10036 }
10037
10038 if( tunneldist != 0 ) {
10039 if( ( tunneldist - 1 ) * 100_kJ
10040 > //The first 100 was already taken up by the bionic's activation cost.
10041 u.get_power_level() ) { //oops, not enough energy! Tunneling costs 100 bionic power per impassable tile
10042 if( tunneldist * 100_kJ >
10044 add_msg( _( "You try to quantum tunnel through the barrier but bounce off! You don't have enough bionic power capacity to travel that far." ) );
10045 } else {
10046 add_msg( _( "You try to quantum tunnel through the barrier but are reflected! You need %i bionic power to travel that thickness of material." ),
10047 ( 100 * tunneldist ) );
10048 }
10049 return false;
10050 }
10051
10052 if( u.in_vehicle ) {
10053 m.unboard_vehicle( u.pos() );
10054 }
10055
10056 add_msg( _( "You quantum tunnel through the %d-tile wide barrier!" ), tunneldist );
10057 //tunneling costs 100 bionic power per impassable tile, but the first 100 was already drained by activation.
10058 u.mod_power_level( -( ( tunneldist - 1 ) * 100_kJ ) );
10059 //tunneling costs 100 moves baseline, 50 per extra tile up to a cap of 500 moves
10060 u.moves -= ( 50 + ( tunneldist * 50 ) );
10061 u.setpos( dest );
10062
10063 if( m.veh_at( u.pos() ).part_with_feature( "BOARDABLE", true ) ) {
10064 m.board_vehicle( u.pos(), &u );
10065 }
10066
10067 u.grab( OBJECT_NONE );
10069 m.creature_on_trap( u );
10070 return true;
10071 }
10072
10073 return false;
10074}
bool worn_with_flag(const std::string &flag, const bodypart_id &bp=bodypart_str_id::NULL_ID()) const
Returns true if the player is wearing an item with the given flag.
Definition: character.cpp:3273
units::energy get_max_power_level() const
Definition: character.cpp:1975
bool has_effect_with_flag(const std::string &flag, body_part bp=num_bp) const
Check if creature has any effect with the given flag.
Definition: creature.cpp:1198
void on_move_effects()
Definition: game.cpp:10274
void board_vehicle(const tripoint &p, player *pl)
Definition: map.cpp:1044
constexpr int sgn(const T x)
Definition: enums.h:8

References _, add_msg(), player::add_msg_if_player(), map::board_vehicle(), map::creature_on_trap(), critter_at(), Character::get_max_power_level(), Character::get_power_level(), avatar::grab(), Creature::has_effect_with_flag(), map::impassable(), Character::in_vehicle, m, m_info, Character::mod_power_level(), Creature::moves, OBJECT_NONE, on_move_effects(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), Character::setpos(), sgn(), u, map::unboard_vehicle(), map::veh_at(), Character::worn_with_flag(), point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

◆ pickup() [1/2]

void game::pickup ( )
private

Definition at line 5887 of file game.cpp.

5888{
5889 const cata::optional<tripoint> examp_ = choose_adjacent_highlight( _( "Pickup where?" ),
5890 _( "There is nothing to pick up nearby." ),
5891 ACTION_PICKUP, false );
5892 if( !examp_ ) {
5893 return;
5894 }
5895 pickup( *examp_ );
5896}

References _, ACTION_PICKUP, choose_adjacent_highlight(), and pickup().

Referenced by handle_action(), and pickup().

◆ pickup() [2/2]

void game::pickup ( const tripoint p)
private

Definition at line 5898 of file game.cpp.

5899{
5900 // Highlight target
5901 shared_ptr_fast<game::draw_callback_t> hilite_cb = make_shared_fast<game::draw_callback_t>( [&]() {
5902 m.drawsq( w_terrain, p, drawsq_params().highlight( true ) );
5903 } );
5904 add_draw_callback( hilite_cb );
5905
5906 pickup::pick_up( p, 0 );
5907}

References add_draw_callback(), map::drawsq(), m, pickup::pick_up(), and w_terrain.

◆ pickup_feet()

void game::pickup_feet ( )
private

Definition at line 5909 of file game.cpp.

5910{
5911 pickup::pick_up( u.pos(), 1 );
5912}

References pickup::pick_up(), Character::pos(), and u.

Referenced by handle_action().

◆ place_critter_around() [1/2]

monster * game::place_critter_around ( const mtype_id id,
const tripoint center,
int  radius 
)

Definition at line 4976 of file game.cpp.

4977{
4978 // TODO: change this into an assert, it must never happen.
4979 if( id.is_null() ) {
4980 return nullptr;
4981 }
4982 return place_critter_around( make_shared_fast<monster>( id ), center, radius );
4983}
monster * place_critter_around(const mtype_id &id, const tripoint &center, int radius)
Definition: game.cpp:4976

References center, and place_critter_around().

Referenced by place_critter_around(), place_critter_at(), replace_stair_monsters(), and start_game().

◆ place_critter_around() [2/2]

monster * game::place_critter_around ( const shared_ptr_fast< monster > &  mon,
const tripoint center,
int  radius,
bool  forced = false 
)

Definition at line 4985 of file game.cpp.

4989{
4991 if( forced || can_place_monster( *mon, center ) ) {
4992 where = center;
4993 }
4994
4995 // This loop ensures the monster is placed as close to the center as possible,
4996 // but all places that equally far from the center have the same probability.
4997 for( int r = 1; r <= radius && !where; ++r ) {
4999 }
5000
5001 if( !where ) {
5002 return nullptr;
5003 }
5004 mon->spawn( *where );
5005 return critter_tracker->add( mon ) ? mon.get() : nullptr;
5006}
static cata::optional< tripoint > choose_where_to_place_monster(const monster &mon, const tripoint_range< tripoint > &range)
Definition: game.cpp:4958
static bool can_place_monster(const monster &mon, const tripoint &p)
Definition: game.cpp:4942

References can_place_monster(), center, choose_where_to_place_monster(), critter_tracker, m, and map::points_in_radius().

◆ place_critter_at() [1/2]

monster * game::place_critter_at ( const mtype_id id,
const tripoint p 
)

Adds critters to the reality bubble, creating them if necessary.

Functions taking a id parameter will construct a monster based on that id, (with default properties). Functions taking a mon parameter will use the supplied monster instance instead (which must not be null). Note: the monster will not be upgraded by these functions, it is placed as is.

place_critter_at will place the creature exactly at the given point.

place_critter_around will place the creature around the center p within the given radius (radius 0 means only the center point is used). The chosen point will be as close to the center as possible.

place_critter_within will place the creature at a random point within that given range. (All points within have equal probability.)

Returns
All functions return null if the creature could not be placed (usually because the target is not suitable for it: may be a solid wall, or air, or already occupied by some creature). If the creature has been placed, it returns a pointer to it (which is the same as the one contained in mon).

Definition at line 4966 of file game.cpp.

4967{
4968 return place_critter_around( id, p, 0 );
4969}

References place_critter_around().

Referenced by fungal_effects::fungalize(), revive_corpse(), fungal_effects::spread_fungus_one_tile(), and update_stair_monsters().

◆ place_critter_at() [2/2]

monster * game::place_critter_at ( const shared_ptr_fast< monster > &  mon,
const tripoint p 
)

Definition at line 4971 of file game.cpp.

4972{
4973 return place_critter_around( mon, p, 0 );
4974}

References place_critter_around().

◆ place_critter_within() [1/2]

monster * game::place_critter_within ( const mtype_id id,
const tripoint_range< tripoint > &  range 
)

Definition at line 5008 of file game.cpp.

5009{
5010 // TODO: change this into an assert, it must never happen.
5011 if( id.is_null() ) {
5012 return nullptr;
5013 }
5014 return place_critter_within( make_shared_fast<monster>( id ), range );
5015}
monster * place_critter_within(const mtype_id &id, const tripoint_range< tripoint > &range)
Definition: game.cpp:5008

References place_critter_within().

Referenced by place_critter_within().

◆ place_critter_within() [2/2]

monster * game::place_critter_within ( const shared_ptr_fast< monster > &  mon,
const tripoint_range< tripoint > &  range 
)

Definition at line 5017 of file game.cpp.

5019{
5020 const cata::optional<tripoint> where = choose_where_to_place_monster( *mon, range );
5021 if( !where ) {
5022 return nullptr;
5023 }
5024 mon->spawn( *where );
5025 return critter_tracker->add( mon ) ? mon.get() : nullptr;
5026}

References choose_where_to_place_monster(), and critter_tracker.

◆ place_player()

point game::place_player ( const tripoint dest)
Dexterity increases chance of avoiding cuts on sharp terrain

Definition at line 9644 of file game.cpp.

9645{
9646 const optional_vpart_position vp1 = m.veh_at( dest_loc );
9647 if( const cata::optional<std::string> label = vp1.get_label() ) {
9648 add_msg( m_info, _( "Label here: %s" ), *label );
9649 }
9650 std::string signage = m.get_signage( dest_loc );
9651 if( !signage.empty() ) {
9652 if( !u.has_trait( trait_ILLITERATE ) ) {
9653 add_msg( m_info, _( "The sign says: %s" ), signage );
9654 } else {
9655 add_msg( m_info, _( "There is a sign here, but you are unable to read it." ) );
9656 }
9657 }
9658 if( m.has_graffiti_at( dest_loc ) ) {
9659 if( !u.has_trait( trait_ILLITERATE ) ) {
9660 add_msg( m_info, _( "Written here: %s" ), m.graffiti_at( dest_loc ) );
9661 } else {
9662 add_msg( m_info, _( "Something is written here, but you are unable to read it." ) );
9663 }
9664 }
9665 // TODO: Move the stuff below to a Character method so that NPCs can reuse it
9666 if( m.has_flag( "ROUGH", dest_loc ) && ( !u.in_vehicle ) && ( !u.is_mounted() ) ) {
9667 if( one_in( 5 ) && u.get_armor_bash( bodypart_id( "foot_l" ) ) < rng( 2, 5 ) ) {
9668 add_msg( m_bad, _( "You hurt your left foot on the %s!" ),
9669 m.has_flag_ter( "ROUGH", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9670 dest_loc ) );
9671 u.deal_damage( nullptr, bodypart_id( "foot_l" ), damage_instance( DT_CUT, 1 ) );
9672 }
9673 if( one_in( 5 ) && u.get_armor_bash( bodypart_id( "foot_r" ) ) < rng( 2, 5 ) ) {
9674 add_msg( m_bad, _( "You hurt your right foot on the %s!" ),
9675 m.has_flag_ter( "ROUGH", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9676 dest_loc ) );
9677 u.deal_damage( nullptr, bodypart_id( "foot_l" ), damage_instance( DT_CUT, 1 ) );
9678 }
9679 }
9680 ///\EFFECT_DEX increases chance of avoiding cuts on sharp terrain
9681 if( m.has_flag( "SHARP", dest_loc ) && !one_in( 3 ) && !x_in_y( 1 + u.dex_cur / 2.0, 40 ) &&
9682 ( !u.in_vehicle && !m.veh_at( dest_loc ) ) && ( !u.has_trait( trait_PARKOUR ) ||
9683 one_in( 4 ) ) && ( u.has_trait( trait_THICKSKIN ) ? !one_in( 8 ) : true ) ) {
9684 if( u.is_mounted() ) {
9685 add_msg( _( "Your %s gets cut!" ), u.mounted_creature->get_name() );
9686 u.mounted_creature->apply_damage( nullptr, bodypart_id( "torso" ), rng( 1, 10 ) );
9687 } else {
9688 const bodypart_id bp = u.get_random_body_part();
9689 if( u.deal_damage( nullptr, bp, damage_instance( DT_CUT, rng( 1, 10 ) ) ).total_damage() > 0 ) {
9690 //~ 1$s - bodypart name in accusative, 2$s is terrain name.
9691 add_msg( m_bad, _( "You cut your %1$s on the %2$s!" ),
9692 body_part_name_accusative( bp->token ),
9693 m.has_flag_ter( "SHARP", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9694 dest_loc ) );
9695 }
9696 }
9697 }
9698 if( m.has_flag( "UNSTABLE", dest_loc ) && !u.is_mounted() ) {
9699 u.add_effect( effect_bouldering, 1_turns, num_bp );
9700 } else if( u.has_effect( effect_bouldering ) ) {
9702 }
9703 if( m.has_flag_ter_or_furn( TFLAG_NO_SIGHT, dest_loc ) ) {
9704 u.add_effect( effect_no_sight, 1_turns, num_bp );
9705 } else if( u.has_effect( effect_no_sight ) ) {
9707 }
9708
9709 // If we moved out of the nonant, we need update our map data
9710 if( m.has_flag( "SWIMMABLE", dest_loc ) && u.has_effect( effect_onfire ) ) {
9711 add_msg( _( "The water puts out the flames!" ) );
9713 if( u.is_mounted() ) {
9714 monster *mon = u.mounted_creature.get();
9715 if( mon->has_effect( effect_onfire ) ) {
9717 }
9718 }
9719 }
9720
9721 if( monster *const mon_ptr = critter_at<monster>( dest_loc ) ) {
9722 // We displaced a monster. It's probably a bug if it wasn't a friendly mon...
9723 // Immobile monsters can't be displaced.
9724 monster &critter = *mon_ptr;
9725 // TODO: handling for ridden creatures other than players mount.
9726 if( !critter.has_effect( effect_ridden ) ) {
9727 if( u.is_mounted() ) {
9728 std::vector<tripoint> valid;
9729 for( const tripoint &jk : m.points_in_radius( critter.pos(), 1 ) ) {
9730 if( is_empty( jk ) ) {
9731 valid.push_back( jk );
9732 }
9733 }
9734 if( !valid.empty() ) {
9735 critter.move_to( random_entry( valid ) );
9736 add_msg( _( "You push the %s out of the way." ), critter.name() );
9737 } else {
9738 add_msg( _( "There is no room to push the %s out of the way." ), critter.name() );
9739 return u.pos().xy();
9740 }
9741 } else {
9742 critter.move_to( u.pos(), false,
9743 true ); // Force the movement even though the player is there right now.
9744 add_msg( _( "You displace the %s." ), critter.name() );
9745 }
9746 } else if( !u.has_effect( effect_riding ) ) {
9747 add_msg( _( "You cannot move the %s out of the way." ), critter.name() );
9748 return u.pos().xy();
9749 }
9750 }
9751
9752 // If the player is in a vehicle, unboard them from the current part
9753 if( u.in_vehicle ) {
9754 m.unboard_vehicle( u.pos() );
9755 }
9756 // Move the player
9757 // Start with z-level, to make it less likely that old functions (2D ones) freak out
9758 if( m.has_zlevels() && dest_loc.z != get_levz() ) {
9759 vertical_shift( dest_loc.z );
9760 }
9761
9762 if( u.is_hauling() && ( !m.can_put_items( dest_loc ) ||
9763 m.has_flag( TFLAG_DEEP_WATER, dest_loc ) ||
9764 vp1 ) ) {
9765 u.stop_hauling();
9766 }
9767 u.setpos( dest_loc );
9768 if( u.is_mounted() ) {
9769 monster *mon = u.mounted_creature.get();
9770 mon->setpos( dest_loc );
9771 mon->process_triggers();
9772 m.creature_in_field( *mon );
9773 }
9774 point submap_shift = update_map( u );
9775 // Important: don't use dest_loc after this line. `update_map` may have shifted the map
9776 // and dest_loc was not adjusted and therefore is still in the un-shifted system and probably wrong.
9777 // If you must use it you can calculate the position in the new, shifted system with
9778 // adjusted_pos = ( old_pos.x - submap_shift.x * SEEX, old_pos.y - submap_shift.y * SEEY, old_pos.z )
9779
9780 //Auto pulp or butcher and Auto foraging
9781 if( get_option<bool>( "AUTO_FEATURES" ) && mostseen == 0 && !u.is_mounted() ) {
9783
9784 const std::string forage_type = get_option<std::string>( "AUTO_FORAGING" );
9785 if( forage_type != "off" ) {
9786 const auto forage = [&]( const tripoint & pos ) {
9787 const auto &xter_t = m.ter( pos ).obj().examine;
9788 const auto &xfurn_t = m.furn( pos ).obj().examine;
9789 const bool forage_everything = forage_type == "both";
9790 const bool forage_bushes = forage_everything || forage_type == "bushes";
9791 const bool forage_trees = forage_everything || forage_type == "trees";
9792 if( xter_t == &iexamine::none ) {
9793 return;
9794 } else if( ( forage_bushes && xter_t == &iexamine::shrub_marloss ) ||
9795 ( forage_bushes && xter_t == &iexamine::shrub_wildveggies ) ||
9796 ( forage_bushes && xter_t == &iexamine::harvest_ter_nectar ) ||
9797 ( forage_trees && xter_t == &iexamine::tree_marloss ) ||
9798 ( forage_trees && xter_t == &iexamine::harvest_ter ) ||
9799 ( forage_trees && xter_t == &iexamine::harvest_ter_nectar )
9800 ) {
9801 xter_t( u, pos );
9802 } else if( ( forage_everything && xfurn_t == &iexamine::harvest_furn ) ||
9803 ( forage_everything && xfurn_t == &iexamine::harvest_furn_nectar )
9804 ) {
9805 xfurn_t( u, pos );
9806 }
9807 };
9808
9809 for( auto &elem : adjacentDir ) {
9810 forage( u.pos() + direction_XY( elem ) );
9811 }
9812 }
9813
9814 const std::string pulp_butcher = get_option<std::string>( "AUTO_PULP_BUTCHER" );
9815 if( pulp_butcher == "butcher" && u.max_quality( quality_id( "BUTCHER" ) ) > INT_MIN ) {
9816 std::vector<item *> corpses;
9817
9818 for( item &it : m.i_at( u.pos() ) ) {
9819 corpses.push_back( &it );
9820 }
9821
9822 if( !corpses.empty() ) {
9823 u.assign_activity( activity_id( "ACT_BUTCHER" ), 0, true );
9824 for( item *it : corpses ) {
9825 u.activity.targets.emplace_back( map_cursor( u.pos() ), it );
9826 }
9827 }
9828 } else if( pulp_butcher == "pulp" || pulp_butcher == "pulp_adjacent" ) {
9829 const auto pulp = [&]( const tripoint & pos ) {
9830 for( const auto &maybe_corpse : m.i_at( pos ) ) {
9831 if( maybe_corpse.is_corpse() && maybe_corpse.can_revive() &&
9832 !maybe_corpse.get_mtype()->bloodType().obj().has_acid ) {
9834 u.activity.placement = m.getabs( pos );
9835 u.activity.auto_resume = true;
9836 u.activity.str_values.push_back( "auto_pulp_no_acid" );
9837 return;
9838 }
9839 }
9840 };
9841
9842 if( pulp_butcher == "pulp_adjacent" ) {
9843 for( auto &elem : adjacentDir ) {
9844 pulp( u.pos() + direction_XY( elem ) );
9845 }
9846 } else {
9847 pulp( u.pos() );
9848 }
9849 }
9850 }
9851
9852 //Autopickup
9853 if( !u.is_mounted() && get_option<bool>( "AUTO_PICKUP" ) && !u.is_hauling() &&
9854 ( !get_option<bool>( "AUTO_PICKUP_SAFEMODE" ) || mostseen == 0 ) &&
9855 ( m.has_items( u.pos() ) || get_option<bool>( "AUTO_PICKUP_ADJACENT" ) ) ) {
9856 pickup::pick_up( u.pos(), -1 );
9857 }
9858
9859 // If the new tile is a boardable part, board it
9860 if( vp1.part_with_feature( "BOARDABLE", true ) && !u.is_mounted() ) {
9861 m.board_vehicle( u.pos(), &u );
9862 }
9863
9864 // Traps!
9865 // Try to detect.
9867 if( u.is_mounted() ) {
9869 } else {
9870 m.creature_on_trap( u );
9871 }
9872 // Drench the player if swimmable
9873 if( m.has_flag( "SWIMMABLE", u.pos() ) &&
9874 !( u.is_mounted() || ( u.in_vehicle && vp1->vehicle().can_float() ) ) ) {
9875 u.drench( 40, { { bp_foot_l, bp_foot_r, bp_leg_l, bp_leg_r } }, false );
9876 }
9877
9878 // List items here
9879 if( !m.has_flag( "SEALED", u.pos() ) ) {
9880 if( get_option<bool>( "NO_AUTO_PICKUP_ZONES_LIST_ITEMS" ) ||
9881 !check_zone( zone_type_id( "NO_AUTO_PICKUP" ), u.pos() ) ) {
9882 if( u.is_blind() && !m.i_at( u.pos() ).empty() ) {
9883 add_msg( _( "There's something here, but you can't see what it is." ) );
9884 } else if( m.has_items( u.pos() ) ) {
9885 std::vector<std::string> names;
9886 std::vector<size_t> counts;
9887 std::vector<item> items;
9888 for( auto &tmpitem : m.i_at( u.pos() ) ) {
9889
9890 std::string next_tname = tmpitem.tname();
9891 std::string next_dname = tmpitem.display_name();
9892 bool by_charges = tmpitem.count_by_charges();
9893 bool got_it = false;
9894 for( size_t i = 0; i < names.size(); ++i ) {
9895 if( by_charges && next_tname == names[i] ) {
9896 counts[i] += tmpitem.charges;
9897 got_it = true;
9898 break;
9899 } else if( next_dname == names[i] ) {
9900 counts[i] += 1;
9901 got_it = true;
9902 break;
9903 }
9904 }
9905 if( !got_it ) {
9906 if( by_charges ) {
9907 names.push_back( tmpitem.tname( tmpitem.charges ) );
9908 counts.push_back( tmpitem.charges );
9909 } else {
9910 names.push_back( tmpitem.display_name( 1 ) );
9911 counts.push_back( 1 );
9912 }
9913 items.push_back( tmpitem );
9914 }
9915 if( names.size() > 10 ) {
9916 break;
9917 }
9918 }
9919 for( size_t i = 0; i < names.size(); ++i ) {
9920 if( !items[i].count_by_charges() ) {
9921 names[i] = items[i].display_name( counts[i] );
9922 } else {
9923 names[i] = items[i].tname( counts[i] );
9924 }
9925 }
9926 int and_the_rest = 0;
9927 for( size_t i = 0; i < names.size(); ++i ) {
9928 //~ number of items: "<number> <item>"
9929 std::string fmt = vgettext( "%1$d %2$s", "%1$d %2$s", counts[i] );
9930 names[i] = string_format( fmt, counts[i], names[i] );
9931 // Skip the first two.
9932 if( i > 1 ) {
9933 and_the_rest += counts[i];
9934 }
9935 }
9936 if( names.size() == 1 ) {
9937 add_msg( _( "You see here %s." ), names[0] );
9938 } else if( names.size() == 2 ) {
9939 add_msg( _( "You see here %s and %s." ), names[0], names[1] );
9940 } else if( names.size() == 3 ) {
9941 add_msg( _( "You see here %s, %s, and %s." ), names[0], names[1], names[2] );
9942 } else if( and_the_rest < 7 ) {
9943 add_msg( vgettext( "You see here %s, %s and %d more item.",
9944 "You see here %s, %s and %d more items.",
9945 and_the_rest ),
9946 names[0], names[1], and_the_rest );
9947 } else {
9948 add_msg( _( "You see here %s and many more items." ), names[0] );
9949 }
9950 }
9951 }
9952 }
9953
9954 if( ( vp1.part_with_feature( "CONTROL_ANIMAL", true ) ||
9955 vp1.part_with_feature( "CONTROLS", true ) ) && u.in_vehicle && !u.is_mounted() ) {
9956 add_msg( _( "There are vehicle controls here." ) );
9957 if( !u.has_trait( trait_id( "WAYFARER" ) ) ) {
9958 add_msg( m_info, _( "%s to drive." ), press_x( ACTION_CONTROL_VEHICLE ) );
9959 }
9960 } else if( vp1.part_with_feature( "CONTROLS", true ) && u.in_vehicle &&
9961 u.is_mounted() ) {
9962 add_msg( _( "There are vehicle controls here but you cannot reach them whilst mounted." ) );
9963 }
9964 return submap_shift;
9965}
std::string body_part_name_accusative(body_part bp, int number)
Returns the matching accusative name of the body_part token, i.e.
Definition: bodypart.cpp:329
void drench(int saturation, const body_part_set &flags, bool ignore_waterproof)
Drenches the player with water, saturation is the percent gotten wet.
Definition: suffer.cpp:1755
bool is_hauling() const
Definition: character.cpp:9198
void stop_hauling()
Definition: character.cpp:9189
bodypart_id get_random_body_part(bool main=false) const
Definition: creature.cpp:1617
void vertical_shift(int z_after)
Actual z-level movement part of vertical_move.
Definition: game.cpp:11105
bool check_zone(const zone_type_id &type, const tripoint &where) const
Definition: game.cpp:6297
std::string furnname(const tripoint &p)
Definition: map.cpp:1464
bool has_flag_ter_or_furn(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2317
bool has_graffiti_at(const tripoint &p) const
Definition: map.cpp:7691
bool has_items(const tripoint &p) const
Checks for existence of items.
Definition: map.cpp:4750
const std::string & graffiti_at(const tripoint &p) const
Definition: map.cpp:7680
bool has_flag_ter(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2307
bool can_put_items(const tripoint &p) const
Definition: map.cpp:2293
void setpos(const tripoint &p) override
Definition: monster.cpp:237
bool move_to(const tripoint &p, bool force=false, bool step_on_critter=false, float stagger_adjustment=1.0)
Attempt to move to p.
Definition: monmove.cpp:1493
void process_triggers()
Definition: monster.cpp:1192
cata::optional< std::string > get_label() const
std::vector< std::string > str_values
bool auto_resume
If true, the activity will be auto-resumed next time the player attempts an identical activity.
void search_surroundings()
Search surrounding squares for traps (and maybe other things in the future).
Definition: player.cpp:743
static const efftype_id effect_riding("riding")
static const trait_id trait_ILLITERATE("ILLITERATE")
static const efftype_id effect_bouldering("bouldering")
static const trait_id trait_PARKOUR("PARKOUR")
static const efftype_id effect_no_sight("no_sight")
static const trait_id trait_THICKSKIN("THICKSKIN")
static const efftype_id effect_onfire("onfire")
point direction_XY(const direction dir)
Definition: line.cpp:433
@ TFLAG_NO_SIGHT
Definition: mapdata.h:283
@ TFLAG_DEEP_WATER
Definition: mapdata.h:301
static std::map< nameFlags, std::vector< std::string > > names
Definition: name.cpp:18
const int INDEFINITELY_LONG
A number that represents the longest possible action.
void shrub_wildveggies(player &p, const tripoint &examp)
Definition: iexamine.cpp:3606
void shrub_marloss(player &p, const tripoint &examp)
Definition: iexamine.cpp:3571
void harvest_ter(player &p, const tripoint &examp)
Definition: iexamine.cpp:2043
void harvest_furn(player &p, const tripoint &examp)
Definition: iexamine.cpp:2022
void harvest_ter_nectar(player &p, const tripoint &examp)
Definition: iexamine.cpp:2031
void harvest_furn_nectar(player &p, const tripoint &examp)
Definition: iexamine.cpp:2013
void tree_marloss(player &p, const tripoint &examp)
Definition: iexamine.cpp:3585
string_id< zone_type > zone_type_id
Definition: type_id.h:192

References _, ACTION_CONTROL_VEHICLE, Character::activity, Creature::add_effect(), add_msg(), Character::assign_activity(), player_activity::auto_resume, map::board_vehicle(), body_part_name_accusative(), bp_foot_l, bp_foot_r, bp_leg_l, bp_leg_r, map::can_put_items(), check_zone(), map::creature_in_field(), map::creature_on_trap(), Character::deal_damage(), Character::dex_cur, direction_XY(), Character::drench(), DT_CUT, EAST, effect_bouldering, effect_no_sight, effect_onfire, effect_ridden, effect_riding, item_stack::empty(), map_data_common_t::examine, map::furn(), map::furnname(), Character::get_armor_bash(), optional_vpart_position::get_label(), get_levz(), Creature::get_random_body_part(), map::get_signage(), map::getabs(), map::graffiti_at(), iexamine::harvest_furn(), iexamine::harvest_furn_nectar(), iexamine::harvest_ter(), iexamine::harvest_ter_nectar(), Creature::has_effect(), map::has_flag(), map::has_flag_ter(), map::has_flag_ter_or_furn(), map::has_graffiti_at(), map::has_items(), Character::has_trait(), map::has_zlevels(), map::i_at(), Character::in_vehicle, calendar::INDEFINITELY_LONG, Character::is_blind(), is_empty(), Character::is_hauling(), Character::is_mounted(), m, m_bad, m_info, visitable< T >::max_quality(), mostseen, Character::mounted_creature, monster::move_to(), monster::name(), Name::names, iexamine::none(), NORTH, NORTHEAST, NORTHWEST, num_bp, int_id< T >::obj(), one_in(), optional_vpart_position::part_with_feature(), pickup::pick_up(), player_activity::placement, map::points_in_radius(), Character::pos(), monster::pos(), press_x(), monster::process_triggers(), random_entry(), Creature::remove_effect(), rng(), player::search_surroundings(), Character::setpos(), monster::setpos(), iexamine::shrub_marloss(), iexamine::shrub_wildveggies(), SOUTH, SOUTHEAST, SOUTHWEST, Character::stop_hauling(), player_activity::str_values, string_format(), player_activity::targets, map::ter(), map::tername(), TFLAG_DEEP_WATER, TFLAG_NO_SIGHT, trait_ILLITERATE, trait_PARKOUR, trait_THICKSKIN, iexamine::tree_marloss(), u, map::unboard_vehicle(), update_map(), map::veh_at(), vertical_shift(), vgettext(), WEST, x_in_y(), tripoint::xy(), and tripoint::z.

Referenced by place_player_overmap(), and walk_move().

◆ place_player_overmap()

void game::place_player_overmap ( const tripoint_abs_omt om_dest)

Definition at line 9967 of file game.cpp.

9968{
9969 // if player is teleporting around, they don't bring their horse with them
9970 if( u.is_mounted() ) {
9972 u.mounted_creature->remove_effect( effect_ridden );
9973 u.mounted_creature = nullptr;
9974 }
9975 // offload the active npcs.
9976 unload_npcs();
9977 for( monster &critter : all_monsters() ) {
9978 despawn_monster( critter );
9979 }
9980 if( u.in_vehicle ) {
9981 m.unboard_vehicle( u.pos() );
9982 }
9983
9985 const int minz = m.has_zlevels() ? -OVERMAP_DEPTH : get_levz();
9986 const int maxz = m.has_zlevels() ? OVERMAP_HEIGHT : get_levz();
9987 for( int z = minz; z <= maxz; z++ ) {
9988 m.clear_vehicle_list( z );
9989 }
9991 // offset because load_map expects the coordinates of the top left corner, but the
9992 // player will be centered in the middle of the map.
9993 // TODO: fix point types
9994 const tripoint map_sm_pos(
9995 project_to<coords::sm>( om_dest ).raw() + point( -HALF_MAPSIZE, -HALF_MAPSIZE ) );
9996 const tripoint player_pos( u.pos().xy(), map_sm_pos.z );
9997 load_map( map_sm_pos );
9998 load_npcs();
9999 m.spawn_monsters( true ); // Static monsters
10001 // update weather now as it could be different on the new location
10003 place_player( player_pos );
10004}
point place_player(const tripoint &dest)
Definition: game.cpp:9644
void unload_npcs()
Unloads all NPCs.
Definition: game.cpp:951
void update_overmap_seen()
Definition: game.cpp:11283
level_cache & access_cache(int zlev)
Definition: map.cpp:8522
void clear_vehicle_list(int zlev)
Definition: map.cpp:327
void clear_vehicle_cache()
Definition: map.cpp:309
std::bitset< MAPSIZE_X *MAPSIZE_Y > map_memory_seen_cache
Definition: map.h:339

References map::access_cache(), all_monsters(), map::clear_vehicle_cache(), map::clear_vehicle_list(), despawn_monster(), effect_ridden, effect_riding, get_levz(), get_weather, HALF_MAPSIZE, map::has_zlevels(), Character::in_vehicle, Character::is_mounted(), load_map(), load_npcs(), m, level_cache::map_memory_seen_cache, Character::mounted_creature, weather_manager::nextweather, OVERMAP_DEPTH, OVERMAP_HEIGHT, place_player(), Character::pos(), Creature::remove_effect(), map::spawn_monsters(), calendar::turn, u, map::unboard_vehicle(), unload_npcs(), update_overmap_seen(), tripoint::xy(), and tripoint::z.

◆ place_vehicle_nearby()

vehicle * game::place_vehicle_nearby ( const vproto_id id,
const point_abs_omt origin,
int  min_distance,
int  max_distance,
const std::vector< std::string > &  omt_search_types = {} 
)
private

Definition at line 847 of file game.cpp.

850{
851 std::vector<std::string> search_types = omt_search_types;
852 if( search_types.empty() ) {
853 vehicle veh( id );
854 if( veh.can_float() ) {
855 search_types.push_back( "river" );
856 search_types.push_back( "lake" );
857 } else {
858 search_types.push_back( "field" );
859 search_types.push_back( "road" );
860 }
861 }
862 for( const std::string &search_type : search_types ) {
863 omt_find_params find_params;
864 find_params.must_see = false;
865 find_params.cant_see = false;
866 find_params.types.emplace_back( search_type, ot_match_type::type );
867 // find nearest road
868 find_params.min_distance = min_distance;
869 find_params.search_range = max_distance;
870 // if player spawns underground, park their car on the surface.
871 const tripoint_abs_omt omt_origin( origin, 0 );
872 for( const tripoint_abs_omt &goal : overmap_buffer.find_all( omt_origin, find_params ) ) {
873 // try place vehicle there.
874 tinymap target_map;
875 target_map.load( project_to<coords::sm>( goal ), false );
876 const tripoint tinymap_center( SEEX, SEEY, goal.z() );
877 static constexpr std::array<units::angle, 4> angles = {{
878 0_degrees, 90_degrees, 180_degrees, 270_degrees
879 }
880 };
881 vehicle *veh = target_map.add_vehicle(
882 id, tinymap_center, random_entry( angles ), rng( 50, 80 ), 0, false );
883 if( veh ) {
884 tripoint abs_local = m.getlocal( target_map.getabs( tinymap_center ) );
885 veh->sm_pos = ms_to_sm_remain( abs_local );
886 veh->pos = abs_local.xy();
888 veh->tracking_on = true;
889 target_map.save();
890 return veh;
891 }
892 }
893 }
894 return nullptr;
895}
void save()
Add currently loaded submaps (in grid) to the mapbuffer.
Definition: map.cpp:6479
vehicle * add_vehicle(const vgroup_id &type, const tripoint &p, units::angle dir, int init_veh_fuel=-1, int init_veh_status=-1, bool merge_wrecks=true)
Definition: mapgen.cpp:5600
void add_vehicle(vehicle *veh)
Add the vehicle to be tracked in the overmap.
std::vector< tripoint_abs_omt > find_all(const tripoint_abs_omt &origin, const omt_find_params &params)
Find all places with the specific overmap terrain type.
Definition: map.h:2065
point pos
Position of the vehicle inside the submap that contains the vehicle.
Definition: vehicle.h:1896
tripoint sm_pos
Submap coordinates of the currently loaded submap (see game::m) that contains this vehicle.
Definition: vehicle.h:1881
bool tracking_on
Definition: vehicle.h:1971
point ms_to_sm_remain(int &x, int &y)
static constexpr int SEEY
Standard arguments for finding overmap terrain.
std::vector< std::pair< std::string, ot_match_type > > types

References map::add_vehicle(), overmapbuffer::add_vehicle(), vehicle::can_float(), omt_find_params::cant_see, overmapbuffer::find_all(), map::getabs(), map::getlocal(), map::load(), m, omt_find_params::min_distance, ms_to_sm_remain(), omt_find_params::must_see, overmap_buffer, vehicle::pos, random_entry(), rng(), map::save(), omt_find_params::search_range, SEEX, SEEY, vehicle::sm_pos, vehicle::tracking_on, type, omt_find_params::types, and tripoint::xy().

Referenced by start_game().

◆ pre_print_all_tile_info()

void game::pre_print_all_tile_info ( const tripoint lp,
const catacurses::window w_info,
int &  line,
int  last_line,
const visibility_variables cache 
)

Definition at line 6839 of file game.cpp.

6842{
6843 // get global area info according to look_around caret position
6844 // TODO: fix point types
6846 lp ) ) ) );
6847 // we only need the area name and then pass it to print_all_tile_info() function below
6848 const std::string area_name = cur_ter_m->get_name();
6849 print_all_tile_info( lp, w_info, area_name, 1, first_line, last_line, cache );
6850}
void print_all_tile_info(const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line, int last_line, const visibility_variables &cache)
Definition: game.cpp:6019
point ms_to_omt_copy(const point &p)
coords::coord_point< tripoint, coords::origin::abs, coords::omt > tripoint_abs_omt
Definition: coordinates.h:493
std::string get_name() const
Definition: omdata.h:205

References oter_t::get_name(), map::getabs(), m, ms_to_omt_copy(), overmap_buffer, print_all_tile_info(), and overmapbuffer::ter().

Referenced by look_around().

◆ print_all_tile_info()

void game::print_all_tile_info ( const tripoint lp,
const catacurses::window w_look,
const std::string &  area_name,
int  column,
int &  line,
int  last_line,
const visibility_variables cache 
)

Definition at line 6019 of file game.cpp.

6024{
6025 visibility_type visibility = VIS_HIDDEN;
6026 const bool inbounds = m.inbounds( lp );
6027 if( inbounds ) {
6028 visibility = m.get_visibility( m.apparent_light_at( lp, cache ), cache );
6029 }
6030 const Creature *creature = critter_at( lp, true );
6031 switch( visibility ) {
6032 case VIS_CLEAR: {
6033 const optional_vpart_position vp = m.veh_at( lp );
6034 print_terrain_info( lp, w_look, area_name, column, line );
6035 print_fields_info( lp, w_look, column, line );
6036 print_trap_info( lp, w_look, column, line );
6037 print_creature_info( creature, w_look, column, line, last_line );
6038 print_vehicle_info( veh_pointer_or_null( vp ), vp ? vp->part_index() : -1, w_look, column, line,
6039 last_line );
6040 print_items_info( lp, w_look, column, line, last_line );
6041 print_graffiti_info( lp, w_look, column, line, last_line );
6042 }
6043 break;
6044 case VIS_BOOMER:
6045 case VIS_BOOMER_DARK:
6046 case VIS_DARK:
6047 case VIS_LIT:
6048 case VIS_HIDDEN:
6049 print_visibility_info( w_look, column, line, visibility );
6050
6051 if( creature != nullptr ) {
6052 std::vector<std::string> buf;
6053 if( u.sees_with_infrared( *creature ) ) {
6054 creature->describe_infrared( buf );
6055 } else if( u.sees_with_specials( *creature ) ) {
6056 creature->describe_specials( buf );
6057 }
6058 for( const std::string &s : buf ) {
6059 mvwprintw( w_look, point( 1, ++line ), s );
6060 }
6061 }
6062 break;
6063 }
6064 if( !inbounds ) {
6065 return;
6066 }
6067 auto this_sound = sounds::sound_at( lp );
6068 if( !this_sound.empty() ) {
6069 mvwprintw( w_look, point( 1, ++line ), _( "You heard %s from here." ), this_sound );
6070 } else {
6071 // Check other z-levels
6072 tripoint tmp = lp;
6073 for( tmp.z = -OVERMAP_DEPTH; tmp.z <= OVERMAP_HEIGHT; tmp.z++ ) {
6074 if( tmp.z == lp.z ) {
6075 continue;
6076 }
6077
6078 auto zlev_sound = sounds::sound_at( tmp );
6079 if( !zlev_sound.empty() ) {
6080 mvwprintw( w_look, point( 1, ++line ), tmp.z > lp.z ?
6081 _( "You heard %s from above." ) : _( "You heard %s from below." ), zlev_sound );
6082 }
6083 }
6084 }
6085}
bool sees_with_specials(const Creature &critter) const
Definition: character.cpp:6440
bool sees_with_infrared(const Creature &critter) const
Check whether the this player can see the other creature with infrared.
void print_fields_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line)
Definition: game.cpp:6189
void print_terrain_info(const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line)
Definition: game.cpp:6116
void print_graffiti_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6281
void print_creature_info(const Creature *creature, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6226
void print_vehicle_info(const vehicle *veh, int veh_part, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6235
void print_items_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6244
void print_visibility_info(const catacurses::window &w_look, int column, int &line, visibility_type visibility)
Definition: game.cpp:6087
void print_trap_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line)
Definition: game.cpp:6207
void line(map *m, const ter_id &type, const point &p1, const point &p2)
Definition: mapgen.cpp:6455
std::string sound_at(const tripoint &location)
Definition: sounds.cpp:605

References _, map::apparent_light_at(), creature, critter_at(), map::get_visibility(), map::inbounds(), line(), m, catacurses::mvwprintw(), OVERMAP_DEPTH, OVERMAP_HEIGHT, print_creature_info(), print_fields_info(), print_graffiti_info(), print_items_info(), print_terrain_info(), print_trap_info(), print_vehicle_info(), print_visibility_info(), Character::sees_with_infrared(), Character::sees_with_specials(), sounds::sound_at(), u, map::veh_at(), veh_pointer_or_null(), VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, VIS_LIT, and tripoint::z.

Referenced by pre_print_all_tile_info().

◆ print_creature_info()

void game::print_creature_info ( const Creature creature,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6226 of file game.cpp.

6228{
6229 int vLines = last_line - line;
6230 if( creature != nullptr && ( u.sees( *creature ) || creature == &u ) ) {
6231 line = creature->print_info( w_look, ++line, vLines, column );
6232 }
6233}

References creature, line(), Character::sees(), and u.

Referenced by print_all_tile_info().

◆ print_fields_info()

void game::print_fields_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line 
)
private

Definition at line 6189 of file game.cpp.

6191{
6192 const field &tmpfield = m.field_at( lp );
6193 for( auto &fld : tmpfield ) {
6194 const field_entry &cur = fld.second;
6195 if( fld.first.obj().has_fire && ( m.has_flag( TFLAG_FIRE_CONTAINER, lp ) ||
6196 m.ter( lp ) == t_pit_shallow || m.ter( lp ) == t_pit ) ) {
6197 const int max_width = getmaxx( w_look ) - column - 2;
6198 int lines = fold_and_print( w_look, point( column, ++line ), max_width, cur.color(),
6199 get_fire_fuel_string( lp ) ) - 1;
6200 line += lines;
6201 } else {
6202 mvwprintz( w_look, point( column, ++line ), cur.color(), cur.name() );
6203 }
6204 }
6205}
An active or passive effect existing on a tile.
Definition: field.h:20
nc_color color() const
Definition: field.cpp:94
std::string name() const
Definition: field.h:84
A variable sized collection of field entries on a given map square.
Definition: field.h:131
ter_id t_pit_shallow
Definition: mapdata.cpp:625
ter_id t_pit
Definition: mapdata.cpp:625

References field_entry::color(), map::field_at(), fold_and_print(), get_fire_fuel_string(), catacurses::getmaxx(), map::has_flag(), line(), m, mvwprintz(), field_entry::name(), t_pit, t_pit_shallow, map::ter(), and TFLAG_FIRE_CONTAINER.

Referenced by print_all_tile_info().

◆ print_graffiti_info()

void game::print_graffiti_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6281 of file game.cpp.

6284{
6285 if( line > last_line ) {
6286 return;
6287 }
6288
6289 const int max_width = getmaxx( w_look ) - column - 2;
6290 if( m.has_graffiti_at( lp ) ) {
6291 fold_and_print( w_look, point( column, ++line ), max_width, c_light_gray,
6292 m.ter( lp ) == t_grave_new ? _( "Graffiti: %s" ) : _( "Inscription: %s" ),
6293 m.graffiti_at( lp ) );
6294 }
6295}
ter_id t_grave_new
Definition: mapdata.cpp:625

References _, c_light_gray, fold_and_print(), catacurses::getmaxx(), map::graffiti_at(), map::has_graffiti_at(), line(), m, t_grave_new, and map::ter().

Referenced by print_all_tile_info().

◆ print_items_info()

void game::print_items_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6244 of file game.cpp.

6247{
6248 if( !m.sees_some_items( lp, u ) ) {
6249 return;
6250 } else if( m.has_flag( "CONTAINER", lp ) && !m.could_see_items( lp, u ) ) {
6251 mvwprintw( w_look, point( column, ++line ), _( "You cannot see what is inside of it." ) );
6252 } else if( u.has_effect( effect_blind ) || u.worn_with_flag( "BLIND" ) ) {
6253 mvwprintz( w_look, point( column, ++line ), c_yellow,
6254 _( "There's something there, but you can't see what it is." ) );
6255 return;
6256 } else {
6257 std::map<std::string, int> item_names;
6258 for( auto &item : m.i_at( lp ) ) {
6259 ++item_names[item.tname()];
6260 }
6261
6262 const int max_width = getmaxx( w_look ) - column - 1;
6263 for( auto it = item_names.begin(); it != item_names.end(); ++it ) {
6264 // last line but not last item
6265 if( line + 1 >= last_line && std::next( it ) != item_names.end() ) {
6266 mvwprintz( w_look, point( column, ++line ), c_yellow, _( "More items here…" ) );
6267 break;
6268 }
6269
6270 if( it->second > 1 ) {
6271 trim_and_print( w_look, point( column, ++line ), max_width, c_white,
6272 pgettext( "%s is the name of the item. %d is the quantity of that item.", "%s [%d]" ),
6273 it->first.c_str(), it->second );
6274 } else {
6275 trim_and_print( w_look, point( column, ++line ), max_width, c_white, it->first );
6276 }
6277 }
6278 }
6279}
bool could_see_items(const tripoint &p, const Creature &who) const
Check if the creature could see items at p if there were any items.
Definition: map.cpp:4726
static const efftype_id effect_blind("blind")

References _, c_white, c_yellow, map::could_see_items(), effect_blind, catacurses::getmaxx(), Creature::has_effect(), map::has_flag(), map::i_at(), line(), m, catacurses::mvwprintw(), mvwprintz(), pgettext(), map::sees_some_items(), item::tname(), trim_and_print(), u, and Character::worn_with_flag().

Referenced by print_all_tile_info().

◆ print_terrain_info()

void game::print_terrain_info ( const tripoint lp,
const catacurses::window w_look,
const std::string &  area_name,
int  column,
int &  line 
)
private

Definition at line 6116 of file game.cpp.

6119{
6120 const int max_width = getmaxx( w_look ) - column - 1;
6121 int lines;
6122
6123 const auto fmt_tile_info = []( const tripoint & lp ) {
6124 map &here = get_map();
6125 std::string ret;
6126 if( debug_mode ) {
6127 ret = string_format( "%s %s", lp.to_string(), here.ter( lp )->id );
6128 if( here.has_furn( lp ) ) {
6129 ret += "; " + here.furn( lp )->id.str();
6130 }
6131 } else {
6132 ret = here.tername( lp );
6133 if( here.has_furn( lp ) ) {
6134 ret += "; " + here.furnname( lp );
6135 }
6136 }
6137 return ret;
6138 };
6139
6140 std::string tile = string_format( "(%s) %s", area_name, fmt_tile_info( lp ) );
6141
6142 if( m.impassable( lp ) ) {
6143 lines = fold_and_print( w_look, point( column, line ), max_width, c_light_gray,
6144 _( "%s; Impassable" ),
6145 tile );
6146 } else {
6147 lines = fold_and_print( w_look, point( column, line ), max_width, c_light_gray,
6148 _( "%s; Movement cost %d" ),
6149 tile, m.move_cost( lp ) * 50 );
6150
6151 const auto ll = get_light_level( std::max( 1.0,
6152 LIGHT_AMBIENT_LIT - m.ambient_light_at( lp ) + 1.0 ) );
6153 mvwprintw( w_look, point( column, ++lines ), _( "Lighting: " ) );
6154 wprintz( w_look, ll.second, ll.first );
6155 }
6156
6157 std::string signage = m.get_signage( lp );
6158 if( !signage.empty() ) {
6159 trim_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
6160 // NOLINTNEXTLINE(cata-text-style): the question mark does not end a sentence
6161 u.has_trait( trait_ILLITERATE ) ? _( "Sign: ???" ) : _( "Sign: %s" ), signage );
6162 }
6163
6164 if( m.has_zlevels() && lp.z > -OVERMAP_DEPTH && !m.has_floor( lp ) ) {
6165 // Print info about stuff below
6166 tripoint below( lp.xy(), lp.z - 1 );
6167 std::string tile_below = fmt_tile_info( below );
6168
6169 if( !m.has_floor_or_support( lp ) ) {
6170 fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
6171 _( "Below: %s; No support" ),
6172 tile_below );
6173 } else {
6174 fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
6175 _( "Below: %s; Walkable" ),
6176 tile_below );
6177 }
6178 }
6179
6180 int map_features = fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
6181 m.features( lp ) );
6182 fold_and_print( w_look, point( column, ++lines ), max_width, c_light_gray, _( "Coverage: %d%%" ),
6183 m.coverage( lp ) );
6184 if( line < lines ) {
6185 line = lines + map_features - 1;
6186 }
6187}
Manage and cache data about a part of the map.
Definition: map.h:372
bool has_floor_or_support(const tripoint &p) const
Definition: map.cpp:2034
float ambient_light_at(const tripoint &p) const
Definition: lightmap.cpp:615
std::string features(const tripoint &p)
Definition: map.cpp:1709
int coverage(const tripoint &p) const
Returns coverage value of the tile.
Definition: map.cpp:6210
const std::string & str() const
Returns the identifier as plain std::string.
Definition: string_id.h:255
static constexpr float LIGHT_AMBIENT_LIT
Definition: lightmap.h:18
std::pair< std::string, nc_color > get_light_level(const float light)
Definition: output.cpp:1621
furn_str_id id
Definition: mapdata.h:490
ter_str_id id
Definition: mapdata.h:458

References _, map::ambient_light_at(), c_dark_gray, c_light_gray, map::coverage(), debug_mode, map::features(), fold_and_print(), map::furn(), map::furnname(), get_light_level(), get_map, map::get_signage(), catacurses::getmaxx(), map::has_floor(), map::has_floor_or_support(), map::has_furn(), Character::has_trait(), map::has_zlevels(), ter_t::id, furn_t::id, map::impassable(), LIGHT_AMBIENT_LIT, line(), m, map::move_cost(), catacurses::mvwprintw(), OVERMAP_DEPTH, cata::hash64_detail::ret, string_id< T >::str(), string_format(), map::ter(), map::tername(), tripoint::to_string(), trait_ILLITERATE, trim_and_print(), u, wprintz(), tripoint::xy(), and tripoint::z.

Referenced by print_all_tile_info().

◆ print_trap_info()

void game::print_trap_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line 
)
private

Definition at line 6207 of file game.cpp.

6209{
6210 const trap &tr = m.tr_at( lp );
6211 if( tr.can_see( lp, u ) ) {
6212 partial_con *pc = m.partial_con_at( lp );
6213 std::string tr_name;
6214 if( pc && tr.loadid == tr_unfinished_construction ) {
6215 const construction &built = pc->id.obj();
6216 tr_name = string_format( _( "Unfinished task: %s, %d%% complete" ), built.description,
6217 pc->counter / 100000 );
6218 } else {
6219 tr_name = tr.name();
6220 }
6221
6222 mvwprintz( w_look, point( column, ++line ), tr.color, tr_name );
6223 }
6224}
partial_con * partial_con_at(const tripoint &p)
Definition: map.cpp:5131
static const trap_str_id tr_unfinished_construction("tr_unfinished_construction")
std::string description
Definition: construction.h:51
construction_id id
Definition: construction.h:33
nc_color color
Definition: trap.h:93

References _, trap::can_see(), trap::color, partial_con::counter, construction::description, partial_con::id, line(), trap::loadid, m, mvwprintz(), trap::name(), int_id< T >::obj(), map::partial_con_at(), string_format(), map::tr_at(), tr_unfinished_construction, and u.

Referenced by print_all_tile_info().

◆ print_vehicle_info()

void game::print_vehicle_info ( const vehicle veh,
int  veh_part,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6235 of file game.cpp.

6237{
6238 if( veh ) {
6239 mvwprintw( w_look, point( column, ++line ), _( "There is a %s there. Parts:" ), veh->name );
6240 line = veh->print_part_list( w_look, ++line, last_line, getmaxx( w_look ), veh_part );
6241 }
6242}
int print_part_list(const catacurses::window &win, int y1, int max_y, int width, int p, int hl=-1, bool detail=false) const
Prints a list of all parts to the screen inside of a boxed window, possibly highlighting a selected o...

References _, catacurses::getmaxx(), line(), catacurses::mvwprintw(), vehicle::name, and vehicle::print_part_list().

Referenced by print_all_tile_info().

◆ print_visibility_info()

void game::print_visibility_info ( const catacurses::window w_look,
int  column,
int &  line,
visibility_type  visibility 
)
private

Definition at line 6087 of file game.cpp.

6089{
6090 const char *visibility_message = nullptr;
6091 switch( visibility ) {
6092 case VIS_CLEAR:
6093 visibility_message = _( "Clearly visible." );
6094 break;
6095 case VIS_BOOMER:
6096 visibility_message = _( "A bright pink blur." );
6097 break;
6098 case VIS_BOOMER_DARK:
6099 visibility_message = _( "A pink blur." );
6100 break;
6101 case VIS_DARK:
6102 visibility_message = _( "Darkness." );
6103 break;
6104 case VIS_LIT:
6105 visibility_message = _( "Bright light." );
6106 break;
6107 case VIS_HIDDEN:
6108 visibility_message = _( "Unseen." );
6109 break;
6110 }
6111
6112 mvwprintw( w_look, point( line, column ), visibility_message );
6113 line += 2;
6114}

References _, line(), catacurses::mvwprintw(), VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, and VIS_LIT.

Referenced by print_all_tile_info().

◆ process_activity()

void game::process_activity ( )
private

Definition at line 1742 of file game.cpp.

1743{
1744 if( !u.activity ) {
1745 return;
1746 }
1747
1748 while( u.moves > 0 && u.activity ) {
1749 u.activity.do_turn( u );
1750 }
1751}
void do_turn(player &p)
Performs the activity for a single turn.

References Character::activity, player_activity::do_turn(), Creature::moves, and u.

Referenced by do_turn().

◆ process_artifact()

void game::process_artifact ( item it,
player p 
)

Definition at line 11856 of file game.cpp.

11857{
11858 const bool worn = p.is_worn( it );
11859 const bool wielded = ( &it == &p.weapon );
11860 std::vector<art_effect_passive> effects = it.type->artifact->effects_carried;
11861 if( worn ) {
11862 const std::vector<art_effect_passive> &ew = it.type->artifact->effects_worn;
11863 effects.insert( effects.end(), ew.begin(), ew.end() );
11864 }
11865 if( wielded ) {
11866 const std::vector<art_effect_passive> &ew = it.type->artifact->effects_wielded;
11867 effects.insert( effects.end(), ew.begin(), ew.end() );
11868 }
11869
11870 if( it.is_tool() ) {
11871 // Recharge it if necessary
11872 if( it.ammo_remaining() < it.ammo_capacity() && calendar::once_every( 1_minutes ) ) {
11873 //Before incrementing charge, check that any extra requirements are met
11874 if( check_art_charge_req( it ) ) {
11875 switch( it.type->artifact->charge_type ) {
11876 case ARTC_NULL:
11877 case NUM_ARTCS:
11878 break; // dummy entries
11879 case ARTC_TIME:
11880 // Once per hour
11881 if( calendar::once_every( 1_hours ) ) {
11882 it.charges++;
11883 }
11884 break;
11885 case ARTC_SOLAR:
11886 if( calendar::once_every( 10_minutes ) &&
11887 is_in_sunlight( p.pos() ) ) {
11888 it.charges++;
11889 }
11890 break;
11891 // Artifacts can inflict pain even on Deadened folks.
11892 // Some weird Lovecraftian thing. ;P
11893 // (So DON'T route them through mod_pain!)
11894 case ARTC_PAIN:
11895 if( calendar::once_every( 1_minutes ) ) {
11896 add_msg( m_bad, _( "You suddenly feel sharp pain for no reason." ) );
11897 p.mod_pain_noresist( 3 * rng( 1, 3 ) );
11898 it.charges++;
11899 }
11900 break;
11901 case ARTC_HP:
11902 if( calendar::once_every( 1_minutes ) ) {
11903 add_msg( m_bad, _( "You feel your body decaying." ) );
11904 p.hurtall( 1, nullptr );
11905 it.charges++;
11906 }
11907 break;
11908 case ARTC_FATIGUE:
11909 if( calendar::once_every( 1_minutes ) ) {
11910 add_msg( m_bad, _( "You feel fatigue seeping into your body." ) );
11911 u.mod_fatigue( 3 * rng( 1, 3 ) );
11912 u.mod_stamina( -90 * rng( 1, 3 ) * rng( 1, 3 ) * rng( 2, 3 ) );
11913 it.charges++;
11914 }
11915 break;
11916 // Portals are energetic enough to charge the item.
11917 // Tears in reality are consumed too, but can't charge it.
11918 case ARTC_PORTAL:
11919 for( const tripoint &dest : m.points_in_radius( p.pos(), 1 ) ) {
11920 m.remove_field( dest, fd_fatigue );
11921 if( m.tr_at( dest ).loadid == tr_portal ) {
11922 add_msg( m_good, _( "The portal collapses!" ) );
11923 m.remove_trap( dest );
11924 it.charges++;
11925 break;
11926 }
11927 }
11928 break;
11929 }
11930 }
11931 }
11932 }
11933
11934 for( const art_effect_passive &i : effects ) {
11935 switch( i ) {
11936 case AEP_STR_UP:
11937 p.mod_str_bonus( +4 );
11938 break;
11939 case AEP_DEX_UP:
11940 p.mod_dex_bonus( +4 );
11941 break;
11942 case AEP_PER_UP:
11943 p.mod_per_bonus( +4 );
11944 break;
11945 case AEP_INT_UP:
11946 p.mod_int_bonus( +4 );
11947 break;
11948 case AEP_ALL_UP:
11949 p.mod_str_bonus( +2 );
11950 p.mod_dex_bonus( +2 );
11951 p.mod_per_bonus( +2 );
11952 p.mod_int_bonus( +2 );
11953 break;
11954 case AEP_SPEED_UP:
11955 // Handled in player::current_speed()
11956 break;
11957
11958 case AEP_PBLUE:
11959 if( p.get_rad() > 0 ) {
11960 p.mod_rad( -1 );
11961 }
11962 break;
11963
11964 case AEP_SMOKE:
11965 if( one_in( 10 ) ) {
11966 tripoint pt( p.posx() + rng( -1, 1 ),
11967 p.posy() + rng( -1, 1 ),
11968 p.posz() );
11969 m.add_field( pt, fd_smoke, rng( 1, 3 ) );
11970 }
11971 break;
11972
11973 case AEP_SNAKES:
11974 break; // Handled in player::hit()
11975
11976 case AEP_EXTINGUISH:
11977 for( const tripoint &dest : m.points_in_radius( p.pos(), 1 ) ) {
11978 m.mod_field_age( dest, fd_fire, -1_turns );
11979 }
11980 break;
11981
11982 case AEP_FUN:
11983 //Bonus fluctuates, wavering between 0 and 30-ish - usually around 12
11984 p.add_morale( MORALE_FEELING_GOOD, rng( 1, 2 ) * rng( 2, 3 ), 0, 3_turns, 0_turns, false );
11985 break;
11986
11987 case AEP_HUNGER:
11988 if( one_in( 100 ) ) {
11989 p.mod_stored_kcal( -10 );
11990 }
11991 break;
11992
11993 case AEP_THIRST:
11994 if( one_in( 120 ) ) {
11995 p.mod_thirst( 1 );
11996 }
11997 break;
11998
11999 case AEP_EVIL:
12000 if( one_in( 150 ) ) { // Once every 15 minutes, on average
12001 p.add_effect( effect_evil, 30_minutes );
12002 if( it.is_armor() ) {
12003 if( !worn ) {
12004 add_msg( _( "You have an urge to wear the %s." ),
12005 it.tname() );
12006 }
12007 } else if( !wielded ) {
12008 add_msg( _( "You have an urge to wield the %s." ),
12009 it.tname() );
12010 }
12011 }
12012 break;
12013
12014 case AEP_SCHIZO:
12015 break; // Handled in player::suffer()
12016
12017 case AEP_RADIOACTIVE:
12018 if( one_in( 4 ) ) {
12019 p.irradiate( 1.0f );
12020 }
12021 break;
12022
12023 case AEP_STR_DOWN:
12024 p.mod_str_bonus( -3 );
12025 break;
12026
12027 case AEP_DEX_DOWN:
12028 p.mod_dex_bonus( -3 );
12029 break;
12030
12031 case AEP_PER_DOWN:
12032 p.mod_per_bonus( -3 );
12033 break;
12034
12035 case AEP_INT_DOWN:
12036 p.mod_int_bonus( -3 );
12037 break;
12038
12039 case AEP_ALL_DOWN:
12040 p.mod_str_bonus( -2 );
12041 p.mod_dex_bonus( -2 );
12042 p.mod_per_bonus( -2 );
12043 p.mod_int_bonus( -2 );
12044 break;
12045
12046 case AEP_SPEED_DOWN:
12047 break; // Handled in player::current_speed()
12048
12049 default:
12050 //Suppress warnings
12051 break;
12052 }
12053 }
12054 // Recalculate, as it might have changed (by mod_*_bonus above)
12055 p.str_cur = p.get_str();
12056 p.int_cur = p.get_int();
12057 p.dex_cur = p.get_dex();
12058 p.per_cur = p.get_per();
12059}
@ ARTC_PORTAL
Definition: artifact.h:69
@ ARTC_FATIGUE
Definition: artifact.h:68
@ ARTC_NULL
Definition: artifact.h:63
@ ARTC_SOLAR
Definition: artifact.h:65
@ NUM_ARTCS
Definition: artifact.h:70
@ ARTC_HP
Definition: artifact.h:67
@ ARTC_TIME
Definition: artifact.h:64
@ ARTC_PAIN
Definition: artifact.h:66
virtual void mod_per_bonus(int nper)
Definition: character.cpp:4200
virtual void mod_dex_bonus(int ndex)
Definition: character.cpp:4195
int str_cur
Definition: character.h:246
void mod_rad(int mod)
Definition: character.cpp:7200
virtual int get_dex() const
Definition: character.cpp:4084
virtual void mod_stored_kcal(int nkcal)
Modifiers for need values exclusive to characters.
Definition: character.cpp:4315
bool is_worn(const item &thing) const
Definition: character.h:1084
virtual int get_int() const
Definition: character.cpp:4092
virtual void mod_fatigue(int nfatigue)
Definition: character.cpp:4446
virtual void mod_str_bonus(int nstr)
Definition: character.cpp:4190
int int_cur
Definition: character.h:248
int get_rad() const
Definition: character.cpp:7190
void add_morale(const morale_type &type, int bonus, int max_bonus=0, const time_duration &duration=1_hours, const time_duration &decay_start=30_minutes, bool capped=false, const itype *item_type=nullptr)
Definition: character.cpp:9105
virtual int get_per() const
Definition: character.cpp:4088
void mod_stamina(int mod)
Definition: character.cpp:7227
void hurtall(int dam, Creature *source, bool disturb=true)
Hurts all body parts for dam, no armor reduction.
Definition: character.cpp:8671
bool irradiate(float rads, bool bypass=false)
Handles mitigation and application of radiation.
Definition: suffer.cpp:1532
virtual void mod_int_bonus(int nint)
Definition: character.cpp:4205
virtual void mod_pain_noresist(int npain)
Definition: creature.cpp:1349
bool is_in_sunlight(const tripoint &p)
Returns true if p is outdoors and it is sunny.
Definition: game.cpp:5159
int ammo_remaining() const
Quantity of ammunition currently loaded in tool, gun or auxiliary gunmod.
Definition: item.cpp:7220
bool is_tool() const
Definition: item.cpp:6797
int ammo_capacity() const
Maximum quantity of ammunition loadable for tool, gun or auxiliary gunmod.
Definition: item.cpp:7247
int charges
Definition: item.h:2195
bool is_armor() const
Definition: item.cpp:6548
const itype * type
Definition: item.h:2156
bool add_field(const tripoint &p, const field_type_id &type_id, int intensity=INT_MAX, const time_duration &age=0_turns, bool hit_player=true)
Add field entry at point, or set intensity if present.
Definition: map.cpp:5386
time_duration mod_field_age(const tripoint &p, const field_type_id &type, const time_duration &offset)
Increment/decrement age of field entry at point.
Definition: map.cpp:5306
void remove_trap(const tripoint &p)
Definition: map.cpp:5251
art_effect_passive
Definition: enums.h:99
@ AEP_EXTINGUISH
Definition: enums.h:114
field_type_id fd_smoke
Definition: field_type.cpp:346
field_type_id fd_fatigue
Definition: field_type.cpp:354
static const efftype_id effect_evil("evil")
static const trap_str_id tr_portal("tr_portal")
const morale_type MORALE_FEELING_GOOD("morale_feeling_good")
cata::value_ptr< islot_artifact > artifact
Definition: itype.h:864

References _, Creature::add_effect(), map::add_field(), Character::add_morale(), add_msg(), AEP_ALL_DOWN, AEP_ALL_UP, AEP_DEX_DOWN, AEP_DEX_UP, AEP_EVIL, AEP_EXTINGUISH, AEP_FUN, AEP_HUNGER, AEP_INT_DOWN, AEP_INT_UP, AEP_PBLUE, AEP_PER_DOWN, AEP_PER_UP, AEP_RADIOACTIVE, AEP_SCHIZO, AEP_SMOKE, AEP_SNAKES, AEP_SPEED_DOWN, AEP_SPEED_UP, AEP_STR_DOWN, AEP_STR_UP, AEP_THIRST, item::ammo_capacity(), item::ammo_remaining(), ARTC_FATIGUE, ARTC_HP, ARTC_NULL, ARTC_PAIN, ARTC_PORTAL, ARTC_SOLAR, ARTC_TIME, itype::artifact, item::charges, check_art_charge_req(), Character::dex_cur, effect_evil, fd_fatigue, fd_fire, fd_smoke, Character::get_dex(), Character::get_int(), Character::get_per(), Character::get_rad(), Character::get_str(), Character::hurtall(), Character::int_cur, Character::irradiate(), item::is_armor(), is_in_sunlight(), item::is_tool(), Character::is_worn(), trap::loadid, m, m_bad, m_good, Character::mod_dex_bonus(), Character::mod_fatigue(), map::mod_field_age(), Character::mod_int_bonus(), Creature::mod_pain_noresist(), Character::mod_per_bonus(), Character::mod_rad(), Character::mod_stamina(), Character::mod_stored_kcal(), Character::mod_str_bonus(), Character::mod_thirst(), MORALE_FEELING_GOOD, NUM_ARTCS, calendar::once_every(), one_in(), Character::per_cur, map::points_in_radius(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), map::remove_field(), map::remove_trap(), rng(), Character::str_cur, item::tname(), map::tr_at(), tr_portal, item::type, u, and Character::weapon.

◆ process_voluntary_act_interrupt()

void game::process_voluntary_act_interrupt ( )
private

Definition at line 1703 of file game.cpp.

1704{
1705 if( u.has_effect( effect_sleep ) ) {
1706 // Can't interrupt
1707 return;
1708 }
1709
1710 bool has_activity = u.activity && u.activity.moves_left > 0;
1711 bool is_travelling = u.has_destination() && !u.omt_path.empty();
1712
1713 if( !has_activity && !is_travelling ) {
1714 // Nohing to interrupt
1715 return;
1716 }
1717
1718 // Key poll may be quite expensive, so limit it to 10 times per second.
1719 static auto last_poll = std::chrono::steady_clock::now();
1720 auto now = std::chrono::steady_clock::now();
1721 int64_t difference = std::chrono::duration_cast<std::chrono::milliseconds>
1722 ( now - last_poll ).count();
1723
1724 if( difference > 100 ) {
1726 last_poll = now;
1727 }
1728
1729 // If player is performing a task and a monster is dangerously close, warn them
1730 // regardless of previous safemode warnings
1731 if( has_activity && !u.has_activity( activity_id( "ACT_AIM" ) ) &&
1733 Creature *hostile_critter = is_hostile_very_close();
1734 if( hostile_critter != nullptr ) {
1736 string_format( _( "The %s is dangerously close!" ),
1737 hostile_critter->get_name() ) );
1738 }
1739 }
1740}
bool has_activity(const activity_id &type) const
Check if player currently has a given activity.
Definition: character.cpp:9236
virtual std::string get_name() const =0
void handle_key_blocking_activity()
Definition: game.cpp:2057
int moves_left
The number of moves remaining in this activity before it is complete.

References _, Character::activity, cancel_activity_or_ignore_query(), effect_sleep, Creature::get_name(), handle_key_blocking_activity(), Character::has_activity(), Character::has_destination(), Creature::has_effect(), hostile_spotted_near, player_activity::is_distraction_ignored(), is_hostile_very_close(), player_activity::moves_left, Character::omt_path, string_format(), and u.

Referenced by do_turn().

◆ prompt_dangerous_tile()

bool game::prompt_dangerous_tile ( const tripoint dest_loc) const

Definition at line 9256 of file game.cpp.

9257{
9258 std::vector<std::string> harmful_stuff = get_dangerous_tile( dest_loc );
9259
9260 if( !harmful_stuff.empty() &&
9261 !query_yn( _( "Really step into %s?" ), enumerate_as_string( harmful_stuff ) ) ) {
9262 return false;
9263 }
9264 if( !harmful_stuff.empty() && u.is_mounted() &&
9265 m.tr_at( dest_loc ).loadid == tr_ledge ) {
9266 add_msg( m_warning, _( "Your %s refuses to move over that ledge!" ),
9267 u.mounted_creature->get_name() );
9268 return false;
9269 }
9270 return true;
9271}

References _, add_msg(), enumerate_as_string(), get_dangerous_tile(), Character::is_mounted(), trap::loadid, m, m_warning, Character::mounted_creature, query_yn(), map::tr_at(), tr_ledge, and u.

Referenced by npc_menu(), and walk_move().

◆ quickload()

void game::quickload ( )
private

Definition at line 11824 of file game.cpp.

11825{
11826 const WORLDPTR active_world = world_generator->active_world;
11827 if( active_world == nullptr ) {
11828 return;
11829 }
11830
11831 if( active_world->save_exists( save_t::from_player_name( u.name ) ) ) {
11832 if( moves_since_last_save != 0 ) { // See if we need to reload anything
11833 MAPBUFFER.reset();
11835 try {
11836 setup();
11837 } catch( const std::exception &err ) {
11838 debugmsg( "Error: %s", err.what() );
11839 }
11841 }
11842 } else {
11843 popup_getkey( _( "No saves for %s yet." ), u.name );
11844 }
11845}
bool load(const std::string &world)
Attempt to load first valid save (if any) in world.
Definition: game.cpp:2833
void setup()
Definition: game.cpp:560
static save_t from_player_name(const std::string &name)
int popup_getkey(const char *const mes, Args &&... args)
Definition: output.h:500
bool save_exists(const save_t &name) const

References _, overmapbuffer::clear(), debugmsg, save_t::from_player_name(), load(), MAPBUFFER, moves_since_last_save, Character::name, overmap_buffer, popup_getkey(), mapbuffer::reset(), WORLD::save_exists(), setup(), u, and world_generator.

Referenced by handle_action().

◆ quicksave()

void game::quicksave ( )

Definition at line 11802 of file game.cpp.

11803{
11804 //Don't autosave if the player hasn't done anything since the last autosave/quicksave,
11805 if( !moves_since_last_save ) {
11806 return;
11807 }
11808 add_msg( m_info, _( "Saving game, this may take a while" ) );
11809
11811 popup.message( "%s", _( "Saving game, this may take a while" ) );
11814
11815 time_t now = time( nullptr ); //timestamp for start of saving procedure
11816
11817 //perform save
11818 save();
11819 //Now reset counters for autosaving, so we don't immediately autosave after a quicksave or autosave.
11821 last_save_timestamp = now;
11822}

References _, add_msg(), last_save_timestamp, m_info, moves_since_last_save, popup(), ui_manager::redraw(), refresh_display(), and save().

Referenced by autosave(), and handle_action().

◆ reenter_fullscreen()

void game::reenter_fullscreen ( )

Definition at line 548 of file game.cpp.

549{
550 if( was_fullscreen ) {
551 if( !fullscreen ) {
553 }
554 }
555}

References fullscreen, toggle_fullscreen(), and was_fullscreen.

Referenced by list_items_monsters(), and look_around().

◆ reload()

void game::reload ( item_location loc,
bool  prompt = false,
bool  empty = true 
)

Definition at line 8846 of file game.cpp.

8847{
8849 item *it = loc.get_item();
8850
8851 // bows etc. do not need to reload. select favorite ammo for them instead
8852 if( it->has_flag( "RELOAD_AND_SHOOT" ) ) {
8854 return;
8855 }
8856
8857 switch( u.rate_action_reload( *it ) ) {
8858 case hint_rating::iffy:
8859 if( ( it->is_ammo_container() || it->is_magazine() ) && it->ammo_remaining() > 0 &&
8860 it->ammo_remaining() == it->ammo_capacity() ) {
8861 add_msg( m_info, _( "The %s is already fully loaded!" ), it->tname() );
8862 return;
8863 }
8864 if( it->is_ammo_belt() ) {
8865 const auto &linkage = it->type->magazine->linkage;
8866 if( linkage && !u.has_charges( *linkage, 1 ) ) {
8867 add_msg( m_info, _( "You need at least one %s to reload the %s!" ),
8868 item::nname( *linkage, 1 ), it->tname() );
8869 return;
8870 }
8871 }
8872 if( it->is_watertight_container() && it->is_container_full() ) {
8873 add_msg( m_info, _( "The %s is already full!" ), it->tname() );
8874 return;
8875 }
8876
8877 // intentional fall-through
8878
8879 case hint_rating::cant:
8880 add_msg( m_info, _( "You can't reload a %s!" ), it->tname() );
8881 return;
8882
8883 case hint_rating::good:
8884 break;
8885 }
8886
8887 bool use_loc = true;
8888 if( !it->has_flag( "ALLOWS_REMOTE_USE" ) ) {
8889 it = loc.obtain( u ).get_item();
8890 use_loc = false;
8891 }
8892
8893 // for holsters and ammo pouches try to reload any contained item
8894 if( it->type->can_use( "holster" ) && !it->contents.empty() ) {
8895 it = &it->contents.front();
8896 }
8897
8898 // for bandoliers we currently defer to iuse_actor methods
8899 if( it->is_bandolier() ) {
8900 auto ptr = dynamic_cast<const bandolier_actor *>
8901 ( it->type->get_use( "bandolier" )->get_actor_ptr() );
8902 ptr->reload( u, *it );
8903 return;
8904 }
8905
8907
8908 if( opt.ammo.get_item() == nullptr ) {
8909 return;
8910 }
8911
8912 if( opt ) {
8913 int moves = opt.moves();
8914 if( it->get_var( "dirt", 0 ) > 7800 ) {
8915 add_msg( m_warning, _( "You struggle to reload the fouled %s." ), it->tname() );
8916 moves += 2500;
8917 }
8918
8919 u.assign_activity( activity_id( "ACT_RELOAD" ), moves, opt.qty() );
8920 if( use_loc ) {
8921 u.activity.targets.emplace_back( loc );
8922 } else {
8923 u.activity.targets.emplace_back( u, const_cast<item *>( opt.target ) );
8924 }
8925 u.activity.targets.push_back( std::move( opt.ammo ) );
8926 }
8927}
bool has_charges(const itype_id &it, int quantity, const std::function< bool(const item &)> &filter=return_true< item >) const
Definition: character.cpp:9612
Store ammo and later reload using it.
Definition: iuse_actor.h:885
int moves() const
Definition: item.cpp:7870
const item * target
Definition: item.h:482
int qty() const
Definition: item.h:485
item_location ammo
Definition: item.h:483
item & front()
this is an artifact of the previous code using front() everywhere for contents.
bool empty() const
item * get_item()
Gets the selected item or nullptr.
item_location obtain(Character &ch, int qty=-1)
Move an item from the location to the character inventory.
double get_var(const std::string &name, double default_value) const
Definition: item.cpp:1024
bool is_ammo_container() const
Definition: item.cpp:6506
bool is_watertight_container() const
Whether this is a container which can be used to store liquids.
Definition: item.cpp:6568
static std::string nname(const itype_id &id, unsigned int quantity=1)
Returns the translated item name for the item with given id.
Definition: item.cpp:9743
bool is_ammo_belt() const
Definition: item.cpp:6411
item_contents contents
Definition: item.h:2157
bool is_container_full(bool allow_bucket=false) const
Whether this item has no more free capacity for its current content.
Definition: item.cpp:6686
bool is_bandolier() const
Definition: item.cpp:6416
bool has_flag(const std::string &flag) const
Definition: item.cpp:5186
bool is_magazine() const
Definition: item.cpp:6401
item_location ammo_location
Definition: player.h:650
const void * ptr(const T *p)
\rst Converts p to const void* for pointer formatting.
static item::reload_option favorite_ammo_or_select(const player &u, const item &it, bool empty, bool prompt)
Definition: game.cpp:8827
@ prompt
Definition: pickup.h:30
const use_function * get_use(const std::string &iuse_name) const
Definition: itype.cpp:91
cata::value_ptr< islot_magazine > magazine
Definition: itype.h:859
bool can_use(const std::string &iuse_name) const
Definition: itype.cpp:86

References _, Character::activity, add_msg(), item::reload_option::ammo, item::ammo_capacity(), player::ammo_location, item::ammo_remaining(), Character::assign_activity(), itype::can_use(), cant, item::contents, item_contents::empty(), favorite_ammo_or_select(), item_contents::front(), use_function::get_actor_ptr(), item_location::get_item(), itype::get_use(), item::get_var(), good, Character::has_charges(), item::has_flag(), iffy, item::is_ammo_belt(), item::is_ammo_container(), item::is_bandolier(), item::is_container_full(), item::is_magazine(), item::is_watertight_container(), m_info, m_warning, itype::magazine, item_location::make_dirty(), avatar_action::move(), item::reload_option::moves(), item::nname(), item_location::obtain(), pickup::prompt, ranged::prompt_select_default_ammo_for(), ptr(), item::reload_option::qty(), player::rate_action_reload(), item::reload_option::target, player_activity::targets, item::tname(), item::type, and u.

Referenced by inventory_item_menu(), reload_item(), and reload_wielded().

◆ reload_item()

void game::reload_item ( )

Definition at line 8930 of file game.cpp.

8931{
8932 item_location item_loc = inv_map_splice( [&]( const item & it ) {
8933 return u.rate_action_reload( it ) == hint_rating::good;
8934 }, _( "Reload item" ), 1, _( "You have nothing to reload." ) );
8935
8936 if( !item_loc ) {
8937 add_msg( _( "Never mind." ) );
8938 return;
8939 }
8940
8941 reload( item_loc );
8942}
item_location inv_map_splice(item_filter filter, const std::string &title, int radius=0, const std::string &none_message="")
Custom-filtered menu for inventory and nearby items and those that within specified radius.

References _, add_msg(), good, inv_map_splice(), player::rate_action_reload(), reload(), and u.

Referenced by handle_action().

◆ reload_npcs()

void game::reload_npcs ( )

Unloads, then loads the NPCs.

Definition at line 960 of file game.cpp.

961{
962 // TODO: Make it not invoke the "on_unload" command for the NPCs that will be loaded anyway
963 // and not invoke "on_load" for those NPCs that avoided unloading this way.
964 unload_npcs();
965 load_npcs();
966}

References load_npcs(), and unload_npcs().

Referenced by load(), overmap_npc_move(), vertical_move(), and vertical_shift().

◆ reload_tileset()

void game::reload_tileset ( )

Definition at line 521 of file game.cpp.

522{
523#if defined(TILES)
524 try {
525 tilecontext->reinit();
526 tilecontext->load_tileset( get_option<std::string>( "TILES" ), false, true );
527 tilecontext->do_tile_loading_report();
528 } catch( const std::exception &err ) {
529 popup( _( "Loading the tileset failed: %s" ), err.what() );
530 }
531 g->reset_zoom();
532 g->mark_main_ui_adaptor_resize();
533#endif // TILES
534}

References _, g, and popup().

Referenced by handle_action().

◆ reload_weapon()

void game::reload_weapon ( bool  try_everything = true)

Definition at line 8954 of file game.cpp.

8955{
8956 // As a special streamlined activity, hitting reload repeatedly should:
8957 // Reload wielded gun
8958 // First reload a magazine if necessary.
8959 // Then load said magazine into gun.
8960 // Reload magazines that are compatible with the current gun.
8961 // Reload other guns in inventory.
8962 // Reload misc magazines in inventory.
8963 std::vector<item_location> reloadables = u.find_reloadables();
8964 std::sort( reloadables.begin(), reloadables.end(),
8965 [this]( const item_location & a, const item_location & b ) {
8966 const item *ap = a.get_item();
8967 const item *bp = b.get_item();
8968 // Current wielded weapon comes first.
8969 if( this->u.is_wielding( *bp ) ) {
8970 return false;
8971 }
8972 if( this->u.is_wielding( *ap ) ) {
8973 return true;
8974 }
8975 // Second sort by affiliation with wielded gun
8976 const std::set<itype_id> compatible_magazines = this->u.weapon.magazine_compatible();
8977 const bool mag_ap = compatible_magazines.count( ap->typeId() ) > 0;
8978 const bool mag_bp = compatible_magazines.count( bp->typeId() ) > 0;
8979 if( mag_ap != mag_bp ) {
8980 return mag_ap;
8981 }
8982 // Third sort by gun vs magazine,
8983 if( ap->is_gun() != bp->is_gun() ) {
8984 return ap->is_gun();
8985 }
8986 // Finally sort by speed to reload.
8987 return ( ap->get_reload_time() * ( ap->ammo_capacity() - ap->ammo_remaining() ) ) <
8988 ( bp->get_reload_time() * ( bp->ammo_capacity() - bp->ammo_remaining() ) );
8989 } );
8990 for( item_location &candidate : reloadables ) {
8991 std::vector<item::reload_option> ammo_list;
8992 u.list_ammo( *candidate.get_item(), ammo_list, false );
8993 if( !ammo_list.empty() ) {
8994 reload( candidate, false, false );
8995 return;
8996 }
8997 }
8998 // Just for testing, bail out here to avoid unwanted side effects.
8999 if( !try_everything ) {
9000 return;
9001 }
9002 // If we make it here and haven't found anything to reload, start looking elsewhere.
9003 vehicle *veh = veh_pointer_or_null( m.veh_at( u.pos() ) );
9004 turret_data turret;
9005 if( veh && ( turret = veh->turret_query( u.pos() ) ) && turret.can_reload() ) {
9006 item::reload_option opt = g->u.select_ammo( *turret.base(), true );
9007 if( opt ) {
9008 g->u.assign_activity( activity_id( "ACT_RELOAD" ), opt.moves(), opt.qty() );
9009 g->u.activity.targets.emplace_back( turret.base() );
9010 g->u.activity.targets.push_back( std::move( opt.ammo ) );
9011 }
9012 return;
9013 }
9014
9015 reload_item();
9016}
std::vector< item_location > find_reloadables()
Searches for weapons and magazines that can be reloaded.
Definition: character.cpp:2697
bool list_ammo(const item &base, std::vector< item::reload_option > &ammo_list, bool include_empty_mags=true, bool include_potential=false) const
Definition: player.cpp:2269
bool can_reload() const
Definition: turret.cpp:212
item_location base()
Get base item location.
Definition: turret.cpp:84
turret_data turret_query(vehicle_part &pt)
Get firing data for a turret.
Definition: turret.cpp:55
constexpr double a
Definition: magic.cpp:1030
constexpr double b
Definition: magic.cpp:1031

References a, b, Character::find_reloadables(), and u.

Referenced by handle_action().

◆ reload_wielded()

void game::reload_wielded ( bool  prompt = false)

Definition at line 8944 of file game.cpp.

8945{
8946 if( u.weapon.is_null() || !u.weapon.is_reloadable() ) {
8947 add_msg( _( "You aren't holding something you can reload." ) );
8948 return;
8949 }
8950 item_location item_loc = item_location( u, &u.weapon );
8951 reload( item_loc, prompt );
8952}
bool is_null() const
Definition: item.cpp:731
bool is_reloadable() const
Is it ever possible to reload this item? Only the base item is considered with any mods ignored.
Definition: item.cpp:9651

References _, add_msg(), item::is_null(), item::is_reloadable(), pickup::prompt, reload(), u, and Character::weapon.

Referenced by handle_action().

◆ remoteveh()

vehicle * game::remoteveh ( )

Returns the current remotely controlled vehicle.

Definition at line 2574 of file game.cpp.

2575{
2577 return remoteveh_cache;
2578 }
2580 std::stringstream remote_veh_string( u.get_value( "remote_controlling_vehicle" ) );
2581 if( remote_veh_string.str().empty() ||
2583 remoteveh_cache = nullptr;
2584 } else {
2585 tripoint vp;
2586 remote_veh_string >> vp.x >> vp.y >> vp.z;
2587 vehicle *veh = veh_pointer_or_null( m.veh_at( vp ) );
2588 if( veh && veh->fuel_left( itype_battery, true ) > 0 ) {
2589 remoteveh_cache = veh;
2590 } else {
2591 remoteveh_cache = nullptr;
2592 }
2593 }
2594 return remoteveh_cache;
2595}
vehicle * remoteveh_cache
Definition: game.h:1093
int fuel_left(const itype_id &ftype, bool recurse=false) const
Definition: vehicle.cpp:3182
static const bionic_id bio_remote("bio_remote")
static const itype_id itype_remotevehcontrol("remotevehcontrol")
static const itype_id itype_battery("battery")

References bio_remote, vehicle::fuel_left(), Creature::get_value(), Character::has_active_bionic(), Character::has_active_item(), itype_battery, itype_remotevehcontrol, m, remoteveh_cache, remoteveh_cache_time, calendar::turn, u, map::veh_at(), veh_pointer_or_null(), tripoint::x, tripoint::y, and tripoint::z.

Referenced by control_vehicle(), and handle_action().

◆ remove_npc_follower()

void game::remove_npc_follower ( const character_id id)

Remove follower id from follower set.

Definition at line 1966 of file game.cpp.

1967{
1968 follower_ids.erase( id );
1969 u.follower_ids.erase( id );
1970}

References follower_ids, player::follower_ids, and u.

Referenced by cleanup_dead().

◆ remove_zombie()

void game::remove_zombie ( const monster critter)

Definition at line 5038 of file game.cpp.

5039{
5040 critter_tracker->remove( critter );
5041}

References critter_tracker.

Referenced by despawn_monster(), disable_robot(), start_game(), and vertical_move().

◆ replace_stair_monsters()

void game::replace_stair_monsters ( )
private

Definition at line 11322 of file game.cpp.

11323{
11324 for( auto &elem : coming_to_stairs ) {
11325 elem.staircount = 0;
11326 const tripoint pnt( elem.pos().xy(), get_levz() );
11327 place_critter_around( make_shared_fast<monster>( elem ), pnt, 10 );
11328 }
11329
11330 coming_to_stairs.clear();
11331}
std::vector< monster > coming_to_stairs
Definition: game.h:1031

References coming_to_stairs, get_levz(), and place_critter_around().

◆ reset_item_list_state()

void game::reset_item_list_state ( const catacurses::window window,
int  height,
bool  bRadiusSort 
)
private

Definition at line 7428 of file game.cpp.

7429{
7430 const int width = getmaxx( window );
7431 for( int i = 1; i < TERMX; i++ ) {
7432 if( i < width ) {
7433 mvwputch( window, point( i, 0 ), c_light_gray, LINE_OXOX ); // -
7434 mvwputch( window, point( i, TERMY - height - 1 ), c_light_gray,
7435 LINE_OXOX ); // -
7436 }
7437
7438 if( i < TERMY - height ) {
7439 mvwputch( window, point( 0, i ), c_light_gray, LINE_XOXO ); // |
7440 mvwputch( window, point( width - 1, i ), c_light_gray, LINE_XOXO ); // |
7441 }
7442 }
7443
7444 mvwputch( window, point_zero, c_light_gray, LINE_OXXO ); // |^
7445 mvwputch( window, point( width - 1, 0 ), c_light_gray, LINE_OOXX ); // ^|
7446
7447 mvwputch( window, point( 0, TERMY - height - 1 ), c_light_gray,
7448 LINE_XXXO ); // |-
7449 mvwputch( window, point( width - 1, TERMY - height - 1 ), c_light_gray,
7450 LINE_XOXX ); // -|
7451
7452 mvwprintz( window, point( 2, 0 ), c_light_green, "<Tab> " );
7453 wprintz( window, c_white, _( "Items" ) );
7454
7455 std::string sSort;
7456 if( bRadiusSort ) {
7457 //~ Sort type: distance.
7458 sSort = _( "<s>ort: dist" );
7459 } else {
7460 //~ Sort type: category.
7461 sSort = _( "<s>ort: cat" );
7462 }
7463
7464 int letters = utf8_width( sSort );
7465
7466 shortcut_print( window, point( getmaxx( window ) - letters, 0 ), c_white, c_light_green, sSort );
7467
7468 std::vector<std::string> tokens;
7469 if( !sFilter.empty() ) {
7470 tokens.emplace_back( _( "<R>eset" ) );
7471 }
7472
7473 tokens.emplace_back( _( "<E>xamine" ) );
7474 tokens.emplace_back( _( "<C>ompare" ) );
7475 tokens.emplace_back( _( "<F>ilter" ) );
7476 tokens.emplace_back( _( "<+/->Priority" ) );
7477
7478 int gaps = tokens.size() + 1;
7479 letters = 0;
7480 int n = tokens.size();
7481 for( int i = 0; i < n; i++ ) {
7482 letters += utf8_width( tokens[i] ) - 2; //length ignores < >
7483 }
7484
7485 int usedwidth = letters;
7486 const int gap_spaces = ( width - usedwidth ) / gaps;
7487 usedwidth += gap_spaces * gaps;
7488 point pos( gap_spaces + ( width - usedwidth ) / 2, TERMY - height - 1 );
7489
7490 for( int i = 0; i < n; i++ ) {
7491 pos.x += shortcut_print( window, pos, c_white, c_light_green,
7492 tokens[i] ) + gap_spaces;
7493 }
7494}
#define LINE_OOXX
Definition: output.h:43
#define LINE_OXXO
Definition: output.h:42

References _, c_light_gray, c_light_green, c_white, catacurses::getmaxx(), LINE_OOXX, LINE_OXOX, LINE_OXXO, LINE_XOXO, LINE_XOXX, LINE_XXXO, mvwprintz(), mvwputch(), point_zero, sFilter, shortcut_print(), TERMX, TERMY, utf8_width(), wprintz(), and point::x.

Referenced by list_items().

◆ reset_light_level()

void game::reset_light_level ( )

Definition at line 3935 of file game.cpp.

3936{
3937 for( float &lev : latest_lightlevels ) {
3938 lev = -std::numeric_limits<float>::max();
3939 }
3940}

References latest_lightlevels.

Referenced by do_turn(), and game().

◆ reset_npc_dispositions()

void game::reset_npc_dispositions ( )
private

Definition at line 3010 of file game.cpp.

3011{
3012 for( auto elem : follower_ids ) {
3013 shared_ptr_fast<npc> npc_to_get = overmap_buffer.find_npc( elem );
3014 if( !npc_to_get ) {
3015 continue;
3016 }
3017 npc *npc_to_add = npc_to_get.get();
3018 npc_to_add->chatbin.missions.clear();
3019 npc_to_add->chatbin.missions_assigned.clear();
3020 npc_to_add->mission = NPC_MISSION_NULL;
3021 npc_to_add->chatbin.mission_selected = nullptr;
3022 npc_to_add->set_attitude( NPCATT_NULL );
3023 npc_to_add->op_of_u.anger = 0;
3024 npc_to_add->op_of_u.fear = 0;
3025 npc_to_add->op_of_u.trust = 0;
3026 npc_to_add->op_of_u.value = 0;
3027 npc_to_add->op_of_u.owed = 0;
3028 npc_to_add->set_fac( faction_id( "no_faction" ) );
3030 npc_to_add->global_omt_location(),
3031 npc_to_add->getID() ) );
3032
3033 }
3034
3035}
void set_attitude(npc_attitude new_attitude)
Definition: npc.cpp:3141
npc_chatbin chatbin
Definition: npc.h:1329
void add_new_mission(mission *miss)
See npc_chatbin::add_new_mission.
Definition: npc.cpp:2637
npc_opinion op_of_u
Definition: npc.h:1328
void set_fac(const faction_id &id)
Definition: npc.cpp:466
std::vector< mission * > missions_assigned
Mission that have been assigned by this NPC to a player character.
Definition: npc.h:752
mission * mission_selected
The mission (if any) that we talk about right now.
Definition: npc.h:757
std::vector< mission * > missions
Missions that the NPC can give out.
Definition: npc.h:748
int value
Definition: npc.h:242
int trust
Definition: npc.h:240
int owed
Definition: npc.h:244
int fear
Definition: npc.h:241
int anger
Definition: npc.h:243

References npc::add_new_mission(), npc_opinion::anger, npc::chatbin, npc_opinion::fear, overmapbuffer::find_npc(), follower_ids, Character::getID(), Character::global_omt_location(), npc::mission, npc_chatbin::mission_selected, npc_chatbin::missions, npc_chatbin::missions_assigned, NPC_MISSION_NULL, NPCATT_NULL, npc::op_of_u, ORIGIN_ANY_NPC, overmap_buffer, npc_opinion::owed, mission::reserve_random(), npc::set_attitude(), npc::set_fac(), npc_opinion::trust, and npc_opinion::value.

Referenced by cleanup_at_end().

◆ reset_zoom()

void game::reset_zoom ( )

Definition at line 7343 of file game.cpp.

7344{
7345#if defined(TILES)
7347 rescale_tileset( tileset_zoom );
7348#endif // TILES
7349}

References DEFAULT_TILESET_ZOOM, and tileset_zoom.

◆ revive_corpse()

bool game::revive_corpse ( const tripoint p,
item it 
)

Revives a corpse at given location.

The monster type and some of its properties are deducted from the corpse. If reviving succeeds, the location is guaranteed to have a new monster there (see critter_at).

Parameters
pThe place where to put the revived monster.
itThe corpse item, it must be a valid corpse (see item::is_corpse).
Returns
Whether the corpse has actually been redivided. Reviving may fail for many reasons, including no space to put the monster, corpse being to much damaged etc. If the monster was revived, the caller should remove the corpse item. If reviving failed, the item is unchanged, as is the environment (no new monsters).

Definition at line 5169 of file game.cpp.

5170{
5171 if( !it.is_corpse() ) {
5172 debugmsg( "Tried to revive a non-corpse." );
5173 return false;
5174 }
5175 shared_ptr_fast<monster> newmon_ptr = make_shared_fast<monster>
5176 ( it.get_mtype()->id );
5177 monster &critter = *newmon_ptr;
5178 critter.init_from_item( it );
5179 if( critter.get_hp() < 1 ) {
5180 // Failed reanimation due to corpse being too burned
5181 return false;
5182 }
5183 if( it.has_flag( "FIELD_DRESS" ) || it.has_flag( "FIELD_DRESS_FAILED" ) ||
5184 it.has_flag( "QUARTERED" ) ) {
5185 // Failed reanimation due to corpse being butchered
5186 return false;
5187 }
5188
5189 critter.no_extra_death_drops = true;
5190 critter.add_effect( effect_downed, 5_turns, num_bp );
5191 for( const item &component : it.components ) {
5192 critter.corpse_components.push_back( component );
5193 }
5194
5195 if( it.get_var( "zlave" ) == "zlave" ) {
5196 critter.add_effect( effect_pacified, 1_turns, num_bp );
5197 critter.add_effect( effect_pet, 1_turns, num_bp );
5198 }
5199
5200 if( it.get_var( "no_ammo" ) == "no_ammo" ) {
5201 for( auto &ammo : critter.ammo ) {
5202 ammo.second = 0;
5203 }
5204 }
5205
5206 return place_critter_at( newmon_ptr, p );
5207}
monster * place_critter_at(const mtype_id &id, const tripoint &p)
Adds critters to the reality bubble, creating them if necessary.
Definition: game.cpp:4966
const mtype * get_mtype() const
Definition: item.cpp:6469
std::list< item > components
Definition: item.h:2158
bool is_corpse() const
Whether this is a corpse item.
Definition: item.cpp:6464
int get_hp(const bodypart_id &) const override
Definition: monster.cpp:2894
bool no_extra_death_drops
Definition: monster.h:480
std::vector< item > corpse_components
Definition: monster.h:457
void init_from_item(const item &itm)
Initialize values like speed / hp from data of an item.
Definition: monster.cpp:2758
static const efftype_id effect_downed("downed")
static const efftype_id effect_pacified("pacified")

References monster::add_effect(), monster::ammo, item::components, monster::corpse_components, debugmsg, effect_downed, effect_pacified, effect_pet, monster::get_hp(), item::get_mtype(), item::get_var(), item::has_flag(), mtype::id, monster::init_from_item(), item::is_corpse(), monster::no_extra_death_drops, num_bp, and place_critter_at().

◆ save()

bool game::save ( )

Returns false if saving failed.

Definition at line 3111 of file game.cpp.

3112{
3113 try {
3114 if( !save_player_data() ||
3116 !save_artifacts() ||
3117 !save_maps() ||
3118 !get_auto_pickup().save_character() ||
3120 !get_safemode().save_character() ||
3121 !write_to_file( get_world_base_save_path() + "/uistate.json", [&]( std::ostream & fout ) {
3122 JsonOut jsout( fout );
3123 uistate.serialize( jsout );
3124 }, _( "uistate data" ) ) ) {
3125 return false;
3126 } else {
3127 world_generator->active_world->add_save( save_t::from_player_name( u.name ) );
3128 return true;
3129 }
3130 } catch( std::ios::failure &err ) {
3131 popup( _( "Failed to save game data" ) );
3132 return false;
3133 }
3134}
void write_to_file(const std::string &path, const std::function< void(std::ostream &)> &writer)
Definition: json.h:580
bool save_player_data()
Definition: game.cpp:3065
void serialize(JsonOut &json) const
@ failure
Definition: behavior.h:20

References _, behavior::failure, save_t::from_player_name(), get_auto_notes_settings(), get_auto_pickup(), get_safemode(), get_world_base_save_path(), Character::name, popup(), save(), save_artifacts(), save_factions_missions_npcs(), save_maps(), save_player_data(), uistatedata::serialize(), u, uistate, world_generator, and write_to_file().

Referenced by handle_action(), quicksave(), and save().

◆ save_artifacts()

bool game::save_artifacts ( )
private

Definition at line 3046 of file game.cpp.

3047{
3048 std::string artfilename = get_world_base_save_path() + "/" + SAVE_ARTIFACTS;
3049 return ::save_artifacts( artfilename );
3050}
bool save_artifacts(const std::string &path)
Definition: artifact.cpp:1277

References get_world_base_save_path(), SAVE_ARTIFACTS(), and save_artifacts().

Referenced by cleanup_at_end(), and save().

◆ save_cyborg()

void game::save_cyborg ( item cyborg,
const tripoint couch_pos,
player installer 
)

Turns Broken Cyborg monster into Cyborg NPC via surgery.

Definition at line 5209 of file game.cpp.

5210{
5211 int assist_bonus = installer.get_effect_int( effect_assisted );
5212
5213 float adjusted_skill = installer.bionics_adjusted_skill( skill_firstaid,
5216 -1 );
5217
5218 int damage = cyborg->damage();
5219 int dmg_lvl = cyborg->damage_level( 4 );
5220 int difficulty = 12;
5221
5222 if( damage != 0 ) {
5223
5224 popup( _( "WARNING: Patient's body is damaged. Difficulty of the procedure is increased by %s." ),
5225 dmg_lvl );
5226
5227 // Damage of the cyborg increases difficulty
5228 difficulty += dmg_lvl;
5229 }
5230
5231 int chance_of_success = bionic_manip_cos( adjusted_skill + assist_bonus, difficulty );
5232 int success = chance_of_success - rng( 1, 100 );
5233
5234 if( !g->u.query_yn(
5235 _( "WARNING: %i percent chance of SEVERE damage to all body parts! Continue anyway?" ),
5236 100 - static_cast<int>( chance_of_success ) ) ) {
5237 return;
5238 }
5239
5240 if( success > 0 ) {
5241 add_msg( m_good, _( "Successfully removed Personality override." ) );
5242 add_msg( m_bad, _( "Autodoc immediately destroys the CBM upon removal." ) );
5243
5244 m.i_rem( couch_pos, cyborg );
5245
5246 const string_id<npc_template> npc_cyborg( "cyborg_rescued" );
5247 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
5248 tmp->normalize();
5249 tmp->load_npc_template( npc_cyborg );
5250 tmp->spawn_at_precise( { get_levx(), get_levy() }, couch_pos );
5252 tmp->hurtall( dmg_lvl * 10, nullptr );
5253 tmp->add_effect( effect_downed, rng( 1_turns, 4_turns ), num_bp, 0, true );
5254 load_npcs();
5255
5256 } else {
5257 const int failure_level = static_cast<int>( std::sqrt( std::abs( success ) * 4.0 * difficulty /
5258 adjusted_skill ) );
5259 const int fail_type = std::min( 5, failure_level );
5260 switch( fail_type ) {
5261 case 1:
5262 case 2:
5263 add_msg( m_info, _( "The removal fails." ) );
5264 add_msg( m_bad, _( "The body is damaged." ) );
5265 cyborg->set_damage( damage + 1000 );
5266 break;
5267 case 3:
5268 case 4:
5269 add_msg( m_info, _( "The removal fails badly." ) );
5270 add_msg( m_bad, _( "The body is badly damaged!" ) );
5271 cyborg->set_damage( damage + 2000 );
5272 break;
5273 case 5:
5274 add_msg( m_info, _( "The removal is a catastrophe." ) );
5275 add_msg( m_bad, _( "The body is destroyed!" ) );
5276 m.i_rem( couch_pos, cyborg );
5277 break;
5278 default:
5279 break;
5280 }
5281
5282 }
5283
5284}
int bionic_manip_cos(float adjusted_skill, int bionic_difficulty)
Definition: bionics.cpp:1889
float bionics_adjusted_skill(const skill_id &most_important_skill, const skill_id &important_skill, const skill_id &least_important_skill, int skill_level=-1)
Calculate skill for (un)installing bionics.
Definition: bionics.cpp:1846
item & set_damage(int qty)
Filter setting damage constrained by min_damage and max_damage.
Definition: item.cpp:713
int damage_level(int max) const
Scale item damage to the given number of levels.
Definition: item.cpp:700
int damage() const
How much damage has the item sustained?
Definition: item.cpp:695
map_stack::iterator i_rem(const tripoint &p, map_stack::const_iterator it)
Definition: map.cpp:4082
static const skill_id skill_computer("computer")
static const efftype_id effect_assisted("assisted")
static const skill_id skill_electronics("electronics")
@ success
Definition: behavior.h:20

References _, add_msg(), bionic_manip_cos(), Character::bionics_adjusted_skill(), item::damage(), item::damage_level(), effect_assisted, effect_downed, g, Creature::get_effect_int(), get_levx(), get_levy(), map::i_rem(), overmapbuffer::insert_npc(), load_npcs(), m, m_bad, m_good, m_info, num_bp, overmap_buffer, popup(), rng(), item::set_damage(), skill_computer, skill_electronics, skill_firstaid, and behavior::success.

◆ save_factions_missions_npcs()

bool game::save_factions_missions_npcs ( )
private

Definition at line 3038 of file game.cpp.

3039{
3040 std::string masterfile = get_world_base_save_path() + "/" + SAVE_MASTER;
3041 return write_to_file( masterfile, [&]( std::ostream & fout ) {
3042 serialize_master( fout );
3043 }, _( "factions data" ) );
3044}
void serialize_master(std::ostream &fout)
Definition: savegame.cpp:1238

References _, get_world_base_save_path(), SAVE_MASTER(), serialize_master(), and write_to_file().

Referenced by cleanup_at_end(), and save().

◆ save_maps()

bool game::save_maps ( )
private

Definition at line 3052 of file game.cpp.

3053{
3054 try {
3055 m.save();
3056 overmap_buffer.save(); // can throw
3057 MAPBUFFER.save(); // can throw
3058 return true;
3059 } catch( const std::exception &err ) {
3060 popup( _( "Failed to save the maps: %s" ), err.what() );
3061 return false;
3062 }
3063}
void save(bool delete_after_save=false)
Store all submaps in this instance into savefiles.
Definition: mapbuffer.cpp:103

References _, m, MAPBUFFER, overmap_buffer, popup(), map::save(), overmapbuffer::save(), and mapbuffer::save().

Referenced by cleanup_at_end(), and save().

◆ save_player_data()

bool game::save_player_data ( )
private

Definition at line 3065 of file game.cpp.

3066{
3067 const std::string playerfile = get_player_base_save_path();
3068
3069 const bool saved_data = write_to_file( playerfile + SAVE_EXTENSION, [&]( std::ostream & fout ) {
3070 serialize( fout );
3071 }, _( "player data" ) );
3072 const bool saved_map_memory = u.save_map_memory();
3073 const bool saved_log = write_to_file( playerfile + SAVE_EXTENSION_LOG, [&](
3074 std::ostream & fout ) {
3075 fout << memorial().dump();
3076 }, _( "player memorial" ) );
3077#if defined(__ANDROID__)
3078 const bool saved_shortcuts = write_to_file( playerfile + SAVE_EXTENSION_SHORTCUTS, [&](
3079 std::ostream & fout ) {
3080 save_shortcuts( fout );
3081 }, _( "quick shortcuts" ) );
3082#endif
3083
3084 return saved_data && saved_map_memory && saved_log
3085#if defined(__ANDROID__)
3086 && saved_shortcuts
3087#endif
3088 ;
3089}
bool save_map_memory()
Definition: avatar.cpp:129
std::string get_player_base_save_path() const
Base path for saving player data.
Definition: game.cpp:12539
void serialize(std::ostream &fout)
Saving and loading functions.
Definition: savegame.cpp:69
std::string dump() const
Concatenates all of the memorial log entries, delimiting them with newlines, and returns the resultin...

References _, memorial_logger::dump(), get_player_base_save_path(), memorial(), SAVE_EXTENSION(), SAVE_EXTENSION_LOG(), SAVE_EXTENSION_SHORTCUTS(), avatar::save_map_memory(), serialize(), u, and write_to_file().

Referenced by save().

◆ serialize()

void game::serialize ( std::ostream &  fout)

Saving and loading functions.

Definition at line 69 of file savegame.cpp.

70{
71 /*
72 * Format version 12: Fully json, save the header. Weather and memorial exist elsewhere.
73 * To prevent (or encourage) confusion, there is no version 8. (cata 0.8 uses v7)
74 */
75 // Header
76 fout << "# version " << savegame_version << std::endl;
77
78 JsonOut json( fout, true ); // pretty-print
79
80 json.start_object();
81 // basic game state information.
82 json.member( "turn", calendar::turn );
84 json.member( "calendar_start", calendar_config._start_of_cataclysm );
85 json.member( "game_start", calendar_config._start_of_game );
86 json.member( "initial_season", static_cast<int>( calendar_config._initial_season ) );
87 json.member( "auto_travel_mode", auto_travel_mode );
88 json.member( "run_mode", static_cast<int>( safe_mode ) );
89 json.member( "mostseen", mostseen );
90 // current map coordinates
91 tripoint pos_sm = m.get_abs_sub();
92 const point pos_om = sm_to_om_remain( pos_sm.x, pos_sm.y );
93 json.member( "levx", pos_sm.x );
94 json.member( "levy", pos_sm.y );
95 json.member( "levz", pos_sm.z );
96 json.member( "om_x", pos_om.x );
97 json.member( "om_y", pos_om.y );
98
99 json.member( "grscent", scent.serialize() );
100 json.member( "typescent", scent.serialize( true ) );
101
102 // Then each monster
103 json.member( "active_monsters", *critter_tracker );
104 json.member( "stair_monsters", coming_to_stairs );
105
106 // save stats.
107 json.member( "kill_tracker", *kill_tracker_ptr );
108 json.member( "stats_tracker", *stats_tracker_ptr );
109 json.member( "achievements_tracker", *achievements_tracker_ptr );
110
111 json.member( "token_provider", *token_provider_ptr );
112
113 json.member( "player", u );
114 Messages::serialize( json );
115
116 json.end_object();
117}
A class that keeps time data other than current time.
Definition: calendar.h:530
season_type _initial_season
Definition: calendar.h:534
time_point _start_of_game
Definition: calendar.h:533
time_point _start_of_cataclysm
Definition: calendar.h:532
pimpl< drop_token_provider > token_provider_ptr
Definition: game.h:1023
std::string serialize(bool is_type=false) const
Definition: savegame.cpp:119
point sm_to_om_remain(int &x, int &y)
void serialize(JsonOut &json)
Definition: messages.cpp:321
calendar_config config
const int savegame_version
Definition: savegame.cpp:57

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, achievements_tracker_ptr, auto_travel_mode, coming_to_stairs, calendar::config, critter_tracker, JsonOut::end_object(), map::get_abs_sub(), kill_tracker_ptr, m, JsonOut::member(), mostseen, safe_mode, savegame_version, scent, scent_map::serialize(), Messages::serialize(), sm_to_om_remain(), JsonOut::start_object(), stats_tracker_ptr, token_provider_ptr, calendar::turn, u, point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

Referenced by save_player_data().

◆ serialize_master()

void game::serialize_master ( std::ostream &  fout)
private

Definition at line 1238 of file savegame.cpp.

1239{
1240 fout << "# version " << savegame_version << std::endl;
1241 try {
1242 JsonOut json( fout, true ); // pretty-print
1243 json.start_object();
1244
1245 json.member( "next_mission_id", next_mission_id );
1246 json.member( "next_npc_id", next_npc_id );
1247
1248 json.member( "active_missions" );
1249 mission::serialize_all( json );
1250
1251 json.member( "factions", *faction_manager_ptr );
1252 json.member( "seed", seed );
1253
1254 json.member( "weather" );
1255 json.start_object();
1256 json.member( "lightning", get_weather().lightning_active );
1257 json.end_object();
1258
1259 json.end_object();
1260 } catch( const JsonError &e ) {
1261 debugmsg( "error saving to %s: %s", SAVE_MASTER, e.c_str() );
1262 }
1263}
Definition: json.h:51
const char * c_str() const noexcept
Definition: json.h:54
static void serialize_all(JsonOut &json)
Definition: savegame.cpp:1229

References JsonError::c_str(), debugmsg, JsonOut::end_object(), faction_manager_ptr, get_weather, JsonOut::member(), next_mission_id, next_npc_id, SAVE_MASTER(), savegame_version, seed, mission::serialize_all(), and JsonOut::start_object().

Referenced by save_factions_missions_npcs().

◆ set_critter_died()

void game::set_critter_died ( )

If invoked, dead will be cleaned this turn.

Definition at line 1874 of file game.cpp.

1875{
1876 critter_died = true;
1877}

References critter_died.

◆ set_driving_view_offset()

void game::set_driving_view_offset ( const point p)

Definition at line 1691 of file game.cpp.

1692{
1693 // remove the previous driving offset,
1694 // store the new offset and apply the new offset.
1701}

References driving_view_offset, u, player::view_offset, point::x, tripoint::x, point::y, and tripoint::y.

Referenced by calc_driving_offset(), and cleanup_at_end().

◆ set_npcs_dirty()

void game::set_npcs_dirty ( )

If invoked, NPCs will be reloaded before next turn.

Definition at line 1869 of file game.cpp.

1870{
1871 npcs_dirty = true;
1872}

References npcs_dirty.

◆ set_safe_mode()

void game::set_safe_mode ( safe_mode_type  mode)

Definition at line 9184 of file game.cpp.

9185{
9186 safe_mode = mode;
9188}

References safe_mode, and safe_mode_warning_logged.

Referenced by handle_action(), and mon_info_update().

◆ set_zoom()

void game::set_zoom ( int  level)

Definition at line 7351 of file game.cpp.

7352{
7353#if defined(TILES)
7354 if( tileset_zoom != level ) {
7355 tileset_zoom = level;
7356 rescale_tileset( tileset_zoom );
7357 }
7358#else
7359 static_cast<void>( level );
7360#endif // TILES
7361}

References tileset_zoom.

Referenced by look_around().

◆ setremoteveh()

void game::setremoteveh ( vehicle veh)

Sets the current remotely controlled vehicle.

Definition at line 2597 of file game.cpp.

2598{
2600 remoteveh_cache = veh;
2601 if( veh != nullptr && !u.has_active_bionic( bio_remote ) &&
2603 debugmsg( "Tried to set remote vehicle without bio_remote or remotevehcontrol" );
2604 veh = nullptr;
2605 }
2606
2607 if( veh == nullptr ) {
2608 u.remove_value( "remote_controlling_vehicle" );
2609 return;
2610 }
2611
2612 std::stringstream remote_veh_string;
2613 const tripoint vehpos = veh->global_pos3();
2614 remote_veh_string << vehpos.x << ' ' << vehpos.y << ' ' << vehpos.z;
2615 u.set_value( "remote_controlling_vehicle", remote_veh_string.str() );
2616}
void remove_value(const std::string &key)
Definition: creature.cpp:1333

References bio_remote, debugmsg, vehicle::global_pos3(), Character::has_active_bionic(), Character::has_active_item(), itype_remotevehcontrol, remoteveh_cache, remoteveh_cache_time, Creature::remove_value(), Creature::set_value(), calendar::turn, u, tripoint::x, tripoint::y, and tripoint::z.

◆ setup()

void game::setup ( )

Definition at line 560 of file game.cpp.

561{
562 loading_ui ui( true );
563 {
566 popup.message( "%s", _( "Please wait while the world data loads…\nLoading core data" ) );
569
571 }
572
574
575 if( get_option<bool>( "ELEVATED_BRIDGES" ) && !get_option<bool>( "ZLEVELS" ) ) {
576 debugmsg( "\"Elevated bridges\" mod requires z-levels to be ENABLED to work properly!" );
577 }
578
579 m = map( get_option<bool>( "ZLEVELS" ) );
580
582 next_mission_id = 1;
583 new_game = true;
584 uquit = QUIT_NO; // We haven't quit the game
585 bVMonsterLookFire = true;
586
587 // invalidate calendar caches in case we were previously playing
588 // a different world
589 calendar::set_eternal_season( ::get_option<bool>( "ETERNAL_SEASON" ) );
590 calendar::set_season_length( ::get_option<int>( "SEASON_LENGTH" ) );
591
594
595 turnssincelastmon = 0; //Auto safe mode init
596
599 coming_to_stairs.clear();
600 active_npc.clear();
601 faction_manager_ptr->clear();
606
607 SCT.vSCT.clear(); //Delete pending messages
608
609 stats().clear();
610 // reset kill counts
611 kill_tracker_ptr->clear();
613 // reset follower list
614 follower_ids.clear();
615 scent.reset();
616
618 remoteveh_cache = nullptr;
619
620 token_provider_ptr->clear();
621 // back to menu for save loading, new game etc
622}
void clear_zombies()
Redirects to the creature_tracker clear() function.
Definition: game.cpp:5043
void load_world_modfiles(loading_ui &ui)
Loads core data and mods from the active world.
Definition: game.cpp:2945
static void clear_all()
Remove all active missions, used to cleanup on exit and before reloading a new game.
Definition: mission.cpp:127
void reset()
Definition: scent_map.cpp:51
static const string_id< weather_type > & NULL_ID()
Returns a null id whose string_id<T>::is_null() must always return true.
void clear_messages()
Definition: messages.cpp:351
void reset_sounds()
Definition: sounds.cpp:565

References _, achievements_tracker_ptr, active_npc, calendar::before_time_starts, bVMonsterLookFire, character_id, explosion_handler::explosion_queue::clear(), stats_tracker::clear(), mission::clear_all(), Messages::clear_messages(), clear_zombies(), coming_to_stairs, debugmsg, faction_manager_ptr, follower_ids, explosion_handler::get_explosion_queue(), get_weather, kill_tracker_ptr, load_core_data(), load_world_modfiles(), m, new_game, next_mission_id, next_npc_id, weather_manager::nextweather, string_id< weather_type >::NULL_ID(), popup(), QUIT_NO, ui_manager::redraw(), refresh_display(), remoteveh_cache, remoteveh_cache_time, scent_map::reset(), sounds::reset_sounds(), scent, SCT, calendar::set_eternal_season(), calendar::set_season_length(), stats(), timed_events, token_provider_ptr, turnssincelastmon, uquit, scrollingcombattext::vSCT, and weather_manager::weather_id.

Referenced by butcher_submenu(), and quickload().

◆ shared_from()

template<typename T >
template shared_ptr_fast< npc > game::shared_from< npc > ( const T &  critter)

Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature).

The function may return an empty pointer if the given critter is not stored anywhere (e.g. it was allocated on the stack, not stored in the critter_tracker nor in active_npc nor is it u).

Definition at line 4896 of file game.cpp.

4897{
4898 if( static_cast<const Creature *>( &critter ) == static_cast<const Creature *>( &u ) ) {
4899 // u is not stored in a shared_ptr, but it won't go out of scope anyway
4900 return std::dynamic_pointer_cast<T>( u_shared_ptr );
4901 }
4902 if( critter.is_monster() ) {
4903 if( const shared_ptr_fast<monster> mon_ptr = critter_tracker->find( critter.pos() ) ) {
4904 if( static_cast<const Creature *>( mon_ptr.get() ) == static_cast<const Creature *>( &critter ) ) {
4905 return std::dynamic_pointer_cast<T>( mon_ptr );
4906 }
4907 }
4908 }
4909 if( critter.is_npc() ) {
4910 for( auto &cur_npc : active_npc ) {
4911 if( static_cast<const Creature *>( cur_npc.get() ) == static_cast<const Creature *>( &critter ) ) {
4912 return std::dynamic_pointer_cast<T>( cur_npc );
4913 }
4914 }
4915 }
4916 return nullptr;
4917}

References active_npc, critter_tracker, u, and u_shared_ptr.

Referenced by list_monsters(), mon_info_update(), and validate_mounted_npcs().

◆ shift_destination_preview()

void game::shift_destination_preview ( const point delta)

Definition at line 12552 of file game.cpp.

12553{
12554 for( tripoint &p : destination_preview ) {
12555 p += delta;
12556 }
12557}

References destination_preview.

◆ shift_monsters()

void game::shift_monsters ( const tripoint shift)
private

Shift all active monsters, the shift vector is the number of shifted submaps.

Monsters that are outside of the reality bubble after shifting are despawned. Note on z-levels: this works with vertical shifts, but currently all monsters are despawned upon a vertical shift.

Definition at line 11557 of file game.cpp.

11558{
11559 // If either shift argument is non-zero, we're shifting.
11560 if( shift == tripoint_zero ) {
11561 return;
11562 }
11563 for( monster &critter : all_monsters() ) {
11564 if( shift.xy() != point_zero ) {
11565 critter.shift( shift.xy() );
11566 }
11567
11568 if( m.inbounds( critter.pos() ) && ( shift.z == 0 || m.has_zlevels() ) ) {
11569 // We're inbounds, so don't despawn after all.
11570 // No need to shift Z-coordinates, they are absolute
11571 continue;
11572 }
11573 // Either a vertical shift or the critter is now outside of the reality bubble,
11574 // anyway: it must be saved and removed.
11575 despawn_monster( critter );
11576 }
11577 // The order in which zombies are shifted may cause zombies to briefly exist on
11578 // the same square. This messes up the mon_at cache, so we need to rebuild it.
11579 critter_tracker->rebuild_cache();
11580}

References all_monsters(), critter_tracker, despawn_monster(), map::has_zlevels(), map::inbounds(), m, point_zero, tripoint_zero, tripoint::xy(), and tripoint::z.

Referenced by update_map(), vertical_move(), and vertical_shift().

◆ slip_down()

bool game::slip_down ( )

Checks if player is able to successfully climb to/from some terrain and not slip down.

Returns
whether player has slipped down
Dexterity decreases chances of slipping while climbing

Definition at line 12559 of file game.cpp.

12560{
12561 ///\EFFECT_DEX decreases chances of slipping while climbing
12562 int climb = u.dex_cur;
12563 if( u.has_trait( trait_BADKNEES ) ) {
12564 climb = climb / 2;
12565 }
12566 if( one_in( climb ) ) {
12567 add_msg( m_bad, _( "You slip while climbing and fall down again." ) );
12568 if( climb <= 1 ) {
12569 add_msg( m_bad, _( "Climbing is impossible in your current state." ) );
12570 }
12571 return true;
12572 }
12573 return false;
12574}
static const trait_id trait_BADKNEES("BADKNEES")

References _, add_msg(), Character::dex_cur, Character::has_trait(), m_bad, one_in(), trait_BADKNEES, and u.

◆ spawn_hallucination()

bool game::spawn_hallucination ( const tripoint p)

Spawns a hallucination at a determined position.

Attempts to spawn a hallucination at given location.

Returns false if the hallucination couldn't be spawned for whatever reason, such as a monster already in the target square.

Returns
Whether or not a hallucination was successfully spawned.

Definition at line 5054 of file game.cpp.

5055{
5056 if( one_in( 100 ) ) {
5057 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
5058 tmp->normalize();
5059 tmp->randomize( NC_HALLU );
5060 tmp->spawn_at_precise( { get_levx(), get_levy() }, p );
5061 if( !critter_at( p, true ) ) {
5063 load_npcs();
5064 return true;
5065 } else {
5066 return false;
5067 }
5068 }
5069
5071 const shared_ptr_fast<monster> phantasm = make_shared_fast<monster>( mt );
5072 phantasm->hallucination = true;
5073 phantasm->spawn( p );
5074
5075 //Don't attempt to place phantasms inside of other creatures
5076 if( !critter_at( phantasm->pos(), true ) ) {
5077 return critter_tracker->add( phantasm );
5078 } else {
5079 return false;
5080 }
5081}
mtype_id get_valid_hallucination() const
static MonsterGenerator & generator()
npc_class_id NC_HALLU("NC_HALLU")

References critter_at(), critter_tracker, MonsterGenerator::generator(), get_levx(), get_levy(), MonsterGenerator::get_valid_hallucination(), overmapbuffer::insert_npc(), load_npcs(), NC_HALLU, one_in(), and overmap_buffer.

◆ spell_events_subscriber()

spell_events & game::spell_events_subscriber ( )

Definition at line 3106 of file game.cpp.

3107{
3108 return *spell_events_ptr;
3109}

References spell_events_ptr.

◆ start_calendar()

void game::start_calendar ( )

Definition at line 12121 of file game.cpp.

12122{
12123 const bool scen_season = scen->has_flag( "SPR_START" ) || scen->has_flag( "SUM_START" ) ||
12124 scen->has_flag( "AUT_START" ) || scen->has_flag( "WIN_START" ) ||
12125 scen->has_flag( "SUM_ADV_START" );
12126
12128 if( scen_season ) {
12129 // Configured starting date overridden by scenario, calendar_config.start is left as Spring 1
12131 get_option<int>( "INITIAL_TIME" );
12132 calendar_config._start_of_game = calendar::turn_zero + 1_hours * get_option<int>( "INITIAL_TIME" );
12133 if( scen->has_flag( "SPR_START" ) ) {
12135 } else if( scen->has_flag( "SUM_START" ) ) {
12138 } else if( scen->has_flag( "AUT_START" ) ) {
12141 } else if( scen->has_flag( "WIN_START" ) ) {
12144 } else if( scen->has_flag( "SUM_ADV_START" ) ) {
12147 } else {
12148 debugmsg( "The Unicorn" );
12149 }
12150 } else {
12151 // No scenario, so use the starting date+time configured in world options
12152 int initial_days = get_option<int>( "INITIAL_DAY" );
12153 if( initial_days == -1 ) {
12154 // 0 - 363 for a 91 day season
12155 initial_days = rng( 0, get_option<int>( "SEASON_LENGTH" ) * 4 - 1 );
12156 }
12158
12159 // Determine the season based off how long the seasons are set to be
12160 // First take the number of season elapsed up to the starting date, then mod by 4 to get the season of the current year
12161 const int season_number = ( initial_days / get_option<int>( "SEASON_LENGTH" ) ) % 4;
12162 if( season_number == 0 ) {
12164 } else if( season_number == 1 ) {
12166 } else if( season_number == 2 ) {
12168 } else {
12170 }
12171
12173 + 1_hours * get_option<int>( "INITIAL_TIME" )
12174 + 1_days * get_option<int>( "SPAWN_DELAY" );
12175 }
12176
12178}
@ WINTER
Definition: calendar.h:21
@ AUTUMN
Definition: calendar.h:20
@ SUMMER
Definition: calendar.h:19
@ SPRING
Definition: calendar.h:18
time_duration season_length() const
Definition: calendar.h:569
const scenario * scen
Definition: game.h:1030
bool has_flag(const std::string &flag) const
Such as a seasonal start, fiery start, surrounded start, etc.
Definition: scenario.cpp:439

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, AUTUMN, calendar::config, debugmsg, scenario::has_flag(), rng(), scen, calendar_config::season_length(), SPRING, SUMMER, calendar::turn, calendar::turn_zero, and WINTER.

Referenced by start_game().

◆ start_game()

bool game::start_game ( )
private

Definition at line 647 of file game.cpp.

648{
649 if( !gamemode ) {
650 gamemode = std::make_unique<special_game>();
651 }
652
653 seed = rng_bits();
654 new_game = true;
657 safe_mode = ( get_option<bool>( "SAFEMODE" ) ? SAFE_MODE_ON : SAFE_MODE_OFF );
658 mostseen = 0; // ...and mostseen is 0, we haven't seen any monsters yet.
660
662
665 popup.message( "%s", _( "Please wait as we build your world" ) );
668
669 load_master();
670 u.setID( assign_npc_id() ); // should be as soon as possible, but *after* load_master
671
675 do {
676 omtstart = start_loc.find_player_initial_location();
677 if( omtstart == overmap::invalid_tripoint ) {
678 if( query_yn(
679 _( "Try again?\n\nIt may require several attempts until the game finds a valid starting location." ) ) ) {
682 } else {
683 return false;
684 }
685 }
686 } while( omtstart == overmap::invalid_tripoint );
687
688 start_loc.prepare_map( omtstart );
689
690 // Place vehicles spawned by scenario or profession, has to be placed very early to avoid bugs.
691 if( u.starting_vehicle &&
692 !place_vehicle_nearby( u.starting_vehicle, omtstart.xy(), 0, 30,
693 std::vector<std::string> {} ) ) {
694 debugmsg( "could not place starting vehicle" );
695 }
696
697 if( scen->has_map_extra() ) {
698 // Map extras can add monster spawn points and similar and should be done before the main
699 // map is loaded.
700 start_loc.add_map_extra( omtstart, scen->get_map_extra() );
701 }
702
703 // TODO: fix point types
704 tripoint lev = project_to<coords::sm>( omtstart ).raw();
705 // The player is centered in the map, but lev[xyz] refers to the top left point of the map
706 lev.x -= HALF_MAPSIZE;
707 lev.y -= HALF_MAPSIZE;
708 load_map( lev );
709
712 // Do this after the map cache has been built!
713 start_loc.place_player( u );
714 // ...but then rebuild it, because we want visibility cache to avoid spawning monsters in sight
717 // Start the overmap with out immediate neighborhood visible, this needs to be after place_player
719 get_option<int>( "DISTANCE_INITIAL_VISIBILITY" ), 0 );
720
721 u.moves = 0;
722 u.process_turn(); // process_turn adds the initial move points
726 u.next_climate_control_check = calendar::before_time_starts; // Force recheck at startup
728
729 //Reset character safe mode/pickup rules
734
735 //Put some NPCs in there!
736 if( get_option<std::string>( "STARTING_NPC" ) == "always" ||
737 ( get_option<std::string>( "STARTING_NPC" ) == "scenario" &&
738 !g->scen->has_flag( "LONE_START" ) ) ) {
740 }
741 //Load NPCs. Set nearby npcs to active.
742 load_npcs();
743 // Spawn the monsters
744 const bool spawn_near =
745 get_option<bool>( "BLACK_ROAD" ) || g->scen->has_flag( "SUR_START" );
746 // Surrounded start ones
747 if( spawn_near ) {
748 start_loc.surround_with_monsters( omtstart, mongroup_id( "GROUP_ZOMBIE" ), 70 );
749 }
750
751 m.spawn_monsters( !spawn_near ); // Static monsters
752
753 // Make sure that no monsters are near the player
754 // This can happen in lab starts
755 if( !spawn_near ) {
756 for( monster &critter : all_monsters() ) {
757 if( rl_dist( critter.pos(), u.pos() ) <= 5 ||
758 m.clear_path( critter.pos(), u.pos(), 40, 1, 100 ) ) {
759 remove_zombie( critter );
760 }
761 }
762 }
763
764 //Create mutation_category_level
766 //Calculate mutation drench protection stats
769 if( scen->has_flag( "FIRE_START" ) ) {
770 start_loc.burn( omtstart, 3, 3 );
771 }
772 if( scen->has_flag( "INFECTED" ) ) {
774 }
775 if( scen->has_flag( "BAD_DAY" ) ) {
776 u.add_effect( effect_flu, 1000_minutes );
777 u.add_effect( effect_drunk, 270_minutes );
778 u.add_morale( MORALE_FEELING_BAD, -100, -100, 50_minutes, 50_minutes );
779 }
780 if( scen->has_flag( "HELI_CRASH" ) ) {
781 start_loc.handle_heli_crash( u );
782 bool success = false;
783 for( auto v : m.get_vehicles() ) {
784 std::string name = v.v->type.str();
785 std::string search = std::string( "helicopter" );
786 if( name.find( search ) != std::string::npos ) {
787 for( const vpart_reference &vp : v.v->get_any_parts( VPFLAG_CONTROLS ) ) {
788 const tripoint pos = vp.pos();
789 u.setpos( pos );
790
791 // Delete the items that would have spawned here from a "corpse"
792 for( auto sp : v.v->parts_at_relative( vp.mount(), true ) ) {
793 vehicle_stack here = v.v->get_items( sp );
794
795 for( auto iter = here.begin(); iter != here.end(); ) {
796 iter = here.erase( iter );
797 }
798 }
799
800 auto mons = critter_tracker->find( pos );
801 if( mons != nullptr ) {
802 critter_tracker->remove( *mons );
803 }
804
805 success = true;
806 break;
807 }
808 if( success ) {
809 v.v->name = "Bird Wreckage";
810 break;
811 }
812 }
813 }
814 }
815 if( scen->has_flag( "BORDERED" ) ) {
816 overmap &starting_om = get_cur_om();
817 for( int z = -OVERMAP_DEPTH; z <= OVERMAP_HEIGHT; z++ ) {
818 starting_om.place_special_forced( overmap_special_id( "world" ), { 0, 0, z },
820 }
821
822 }
823 for( auto &e : u.inv_dump() ) {
824 e->set_owner( g->u );
825 }
826 // Now that we're done handling coordinates, ensure the player's submap is in the center of the map
827 update_map( u );
828 // Profession pets
829 for( const mtype_id &elem : u.starting_pets ) {
830 if( monster *const mon = place_critter_around( elem, u.pos(), 5 ) ) {
831 mon->friendly = -1;
832 mon->add_effect( effect_pet, 1_turns, num_bp );
833 } else {
834 add_msg( m_debug, "cannot place starting pet, no space!" );
835 }
836 }
837 // Assign all of this scenario's missions to the player.
838 for( const mission_type_id &m : scen->missions() ) {
839 const auto mission = mission::reserve_new( m, character_id() );
840 mission->assign( u );
841 }
842
843 g->events().send<event_type::game_start>( u.getID() );
844 return true;
845}
body_part random_body_part(bool main_parts_only)
Returns a random body_part token.
Definition: bodypart.cpp:364
bool last_climate_control_ret
Definition: character.h:2220
void drench_mut_calc()
Recalculates mutation drench protection for all bodyparts (ignored/good/neutral stats)
Definition: character.cpp:7960
void set_stamina(int new_stamina)
Definition: character.cpp:7222
time_point next_climate_control_check
Definition: character.h:2219
int get_stamina_max() const
Definition: character.cpp:7213
void set_highest_cat_level()
Recalculates mutation_category_level[] values for the player.
Definition: character.cpp:7937
void default_initialize()
Perform default initialization.
Definition: auto_note.cpp:101
void start_calendar()
Definition: game.cpp:12121
void create_starting_npcs()
Definition: game.cpp:973
overmap & get_cur_om() const
The overmap which contains the center submap of the reality bubble.
Definition: game.cpp:12419
vehicle * place_vehicle_nearby(const vproto_id &id, const point_abs_omt &origin, int min_distance, int max_distance, const std::vector< std::string > &omt_search_types={})
Definition: game.cpp:847
bool clear_path(const tripoint &f, const tripoint &t, int range, int cost_min, int cost_max) const
Check whether there's a direct line of sight between F and T with the additional movecost restraints.
Definition: map.cpp:6360
static mission * reserve_new(const mission_type_id &type, const character_id &npc_id)
Create a new mission of the given type and assign it to the given npc.
Definition: mission.cpp:64
void assign(avatar &u)
Assigns the mission to the player.
Definition: mission.cpp:210
void place_special_forced(const overmap_special_id &special_id, const tripoint_om_omt &p, om_direction::type dir)
Definition: overmap.cpp:2163
bool reveal(const point_abs_omt &center, int radius, int z)
Mark a square area around center on Z-level z as seen.
bool random_start_location
Definition: player.h:644
vproto_id starting_vehicle
Definition: player.h:656
std::vector< mtype_id > starting_pets
Definition: player.h:657
start_location_id start_location
Definition: player.h:645
void clear_character_rules()
bool has_map_extra() const
Definition: scenario.cpp:454
const std::string & get_map_extra() const
Definition: scenario.cpp:458
const std::vector< mission_type_id > & missions() const
Definition: scenario.cpp:462
start_location_id random_start_location() const
Definition: scenario.cpp:232
void burn(const tripoint_abs_omt &omtstart, size_t count, int rad) const
Burn random terrain / furniture with FLAMMABLE or FLAMMABLE_ASH tag.
void surround_with_monsters(const tripoint_abs_omt &omtstart, const mongroup_id &type, float expected_points) const
Adds surround start monsters.
void prepare_map(const tripoint_abs_omt &omtstart) const
Initialize the map at players start location using prepare_map.
void place_player(player &u) const
Place the player somewhere in the reality bubble (g->m).
void handle_heli_crash(player &u) const
tripoint_abs_omt find_player_initial_location() const
Find a suitable start location on the overmap.
void add_map_extra(const tripoint_abs_omt &omtstart, const std::string &map_extra) const
Adds a map extra, see map_extras.h and map_extras.cpp.
const T & obj() const
Returns the actual object this id refers to.
Definition: achievement.cpp:58
iterator erase(const_iterator it) override
Definition: vehicle.cpp:230
static const efftype_id effect_drunk("drunk")
static const efftype_id effect_infected("infected")
static const efftype_id effect_accumulated_mutagen("accumulated_mutagen")
static const efftype_id effect_flu("flu")
static constexpr int SPRING_TEMPERATURE
Base starting spring temperature in F used for climate, weather and temperature calculation.
void update_weather()
Definition: weather.cpp:1056
const morale_type MORALE_FEELING_BAD("morale_feeling_bad")
static bool search(const ui_adaptor &om_ui, tripoint_abs_omt &curs, const tripoint_abs_omt &orig)
unsigned int rng_bits()
Definition: rng.cpp:12
string_id< overmap_special > overmap_special_id
Definition: type_id.h:127
string_id< MonsterGroup > mongroup_id
Definition: type_id.h:98
@ VPFLAG_CONTROLS
Definition: veh_type.h:41

References _, Creature::add_effect(), start_location::add_map_extra(), Character::add_morale(), add_msg(), all_monsters(), mission::assign(), assign_npc_id(), calendar::before_time_starts, item_stack::begin(), map::build_map_cache(), start_location::burn(), character_id, auto_notes::auto_note_settings::clear(), overmapbuffer::clear(), auto_pickup::player_settings::clear_character_rules(), safemode::clear_character_rules(), map::clear_path(), create_starting_npcs(), critter_tracker, debugmsg, auto_notes::auto_note_settings::default_initialize(), Character::drench_mut_calc(), effect_accumulated_mutagen, effect_drunk, effect_flu, effect_infected, effect_pet, item_stack::end(), vehicle_stack::erase(), start_location::find_player_initial_location(), g, game_start, gamemode, get_auto_notes_settings(), get_auto_pickup(), get_cur_om(), get_levz(), scenario::get_map_extra(), get_safemode(), Character::get_stamina_max(), map::get_vehicles(), get_weather, Character::getID(), Character::global_omt_location(), HALF_MAPSIZE, start_location::handle_heli_crash(), scenario::has_flag(), scenario::has_map_extra(), init_autosave(), Character::inv_dump(), overmap::invalid_tripoint, map::invalidate_map_cache(), Character::last_climate_control_ret, safemode::load_global(), load_map(), load_master(), load_npcs(), m, m_debug, MAPBUFFER, scenario::missions(), MORALE_FEELING_BAD, mostseen, Creature::moves, om_direction::name(), new_game, Character::next_climate_control_check, weather_manager::nextweather, om_direction::north, num_bp, string_id< T >::obj(), overmap_buffer, OVERMAP_DEPTH, OVERMAP_HEIGHT, place_critter_around(), start_location::place_player(), overmap::place_special_forced(), place_vehicle_nearby(), popup(), Character::pos(), start_location::prepare_map(), player::process_turn(), query_yn(), random_body_part(), player::random_start_location, scenario::random_start_location(), ui_manager::redraw(), refresh_display(), remove_zombie(), mission::reserve_new(), mapbuffer::reset(), overmapbuffer::reveal(), rl_dist(), rng_bits(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, scen, overmap_ui::search(), seed, Character::set_highest_cat_level(), Character::set_stamina(), Character::setID(), Character::setpos(), map::spawn_monsters(), SPRING_TEMPERATURE, start_calendar(), player::start_location, player::starting_pets, player::starting_vehicle, behavior::success, start_location::surround_with_monsters(), weather_manager::temperature, calendar::turn, u, update_map(), weather_manager::update_weather(), VPFLAG_CONTROLS, tripoint::x, coords::coord_point< Point, Origin, Scale >::xy(), and tripoint::y.

◆ start_hauling()

void game::start_hauling ( const tripoint pos)

Definition at line 10920 of file game.cpp.

10921{
10922 // Find target items and quantities thereof for the new activity
10923 std::vector<item_location> target_items;
10924 std::vector<int> quantities;
10925
10926 map_stack items = m.i_at( pos );
10927 for( item &it : items ) {
10928 // Liquid cannot be picked up
10929 if( it.made_of( LIQUID ) ) {
10930 continue;
10931 }
10932 target_items.emplace_back( map_cursor( pos ), &it );
10933 // Quantity of 0 means move all
10934 quantities.push_back( 0 );
10935 }
10936
10937 if( target_items.empty() ) {
10938 // Nothing to haul
10939 return;
10940 }
10941
10942 // Whether the destination is inside a vehicle (not supported)
10943 const bool to_vehicle = false;
10944 // Destination relative to the player
10945 const tripoint relative_destination{};
10946
10948 target_items,
10949 quantities,
10950 to_vehicle,
10951 relative_destination
10952 ) ) );
10953}

References Character::assign_activity(), map::i_at(), LIQUID, m, and u.

Referenced by vertical_move(), and walk_move().

◆ stats()

stats_tracker & game::stats ( )

Definition at line 3096 of file game.cpp.

3097{
3098 return *stats_tracker_ptr;
3099}

References stats_tracker_ptr.

Referenced by death_screen(), handle_action(), setup(), and win().

◆ swap_critters()

bool game::swap_critters ( Creature a,
Creature b 
)

Swaps positions of two creatures.

Definition at line 5083 of file game.cpp.

5084{
5085 if( &a == &b ) {
5086 // No need to do anything, but print a debugmsg anyway
5087 debugmsg( "Tried to swap %s with itself", a.disp_name() );
5088 return true;
5089 }
5090 if( critter_at( a.pos() ) != &a ) {
5091 debugmsg( "Tried to swap when it would cause a collision between %s and %s.",
5092 b.disp_name(), critter_at( a.pos() )->disp_name() );
5093 return false;
5094 }
5095 if( critter_at( b.pos() ) != &b ) {
5096 debugmsg( "Tried to swap when it would cause a collision between %s and %s.",
5097 a.disp_name(), critter_at( b.pos() )->disp_name() );
5098 return false;
5099 }
5100 // Simplify by "sorting" the arguments
5101 // Only the first argument can be u
5102 // If swapping player/npc with a monster, monster is second
5103 bool a_first = a.is_player() ||
5104 ( a.is_npc() && !b.is_player() );
5105 Creature &first = a_first ? a : b;
5106 Creature &second = a_first ? b : a;
5107 // Possible options:
5108 // both first and second are monsters
5109 // second is a monster, first is a player or an npc
5110 // first is a player, second is an npc
5111 // both first and second are npcs
5112 if( first.is_monster() ) {
5113 monster *m1 = dynamic_cast< monster * >( &first );
5114 monster *m2 = dynamic_cast< monster * >( &second );
5115 if( m1 == nullptr || m2 == nullptr || m1 == m2 ) {
5116 debugmsg( "Couldn't swap two monsters" );
5117 return false;
5118 }
5119
5120 critter_tracker->swap_positions( *m1, *m2 );
5121 return true;
5122 }
5123
5124 player *u_or_npc = dynamic_cast< player * >( &first );
5125 player *other_npc = dynamic_cast< player * >( &second );
5126
5127 if( u_or_npc->in_vehicle ) {
5128 m.unboard_vehicle( u_or_npc->pos() );
5129 }
5130
5131 if( other_npc && other_npc->in_vehicle ) {
5132 m.unboard_vehicle( other_npc->pos() );
5133 }
5134
5135 tripoint temp = second.pos();
5136 second.setpos( first.pos() );
5137
5138 if( first.is_player() ) {
5139 walk_move( temp );
5140 } else {
5141 first.setpos( temp );
5142 if( m.veh_at( u_or_npc->pos() ).part_with_feature( VPFLAG_BOARDABLE, true ) ) {
5143 m.board_vehicle( u_or_npc->pos(), u_or_npc );
5144 }
5145 }
5146
5147 if( other_npc && m.veh_at( other_npc->pos() ).part_with_feature( VPFLAG_BOARDABLE, true ) ) {
5148 m.board_vehicle( other_npc->pos(), other_npc );
5149 }
5150 return true;
5151}
virtual bool is_monster() const
Definition: creature.h:101
virtual bool is_player() const
Definition: creature.h:92
virtual void setpos(const tripoint &pos)=0
bool walk_move(const tripoint &dest, bool via_ramp=false)
Definition: game.cpp:9322
@ VPFLAG_BOARDABLE
Definition: veh_type.h:39

References a, b, map::board_vehicle(), critter_at(), critter_tracker, debugmsg, Character::in_vehicle, Creature::is_monster(), Creature::is_player(), m, optional_vpart_position::part_with_feature(), Creature::pos(), Character::pos(), second, Creature::setpos(), map::unboard_vehicle(), map::veh_at(), VPFLAG_BOARDABLE, and walk_move().

Referenced by npc_menu().

◆ take_screenshot() [1/2]

bool game::take_screenshot ( ) const

Saves a screenshot of the current viewport, as a PNG file.

Filesystem location is derived from the current world and character.

Note
: Only works for SDL/TILES (otherwise the function returns false). A window (more precisely, a viewport) must already exist and the SDL renderer must be valid.
Returns
true if the screenshot generation was successful, false otherwise.

Definition at line 7420 of file game.cpp.

7421{
7422 popup( _( "This binary was not compiled with tiles support." ) );
7423 return false;
7424}

References _, and popup().

Referenced by do_turn().

◆ take_screenshot() [2/2]

bool game::take_screenshot ( const std::string &  file_path) const

Saves a screenshot of the current viewport, as a PNG file, to the given location.

Parameters
file_pathA full path to the file where the screenshot should be saved.
Note
: Only works for SDL/TILES (otherwise the function returns false). A window (more precisely, a viewport) must already exist and the SDL renderer must be valid.
Returns
true if the screenshot generation was successful, false otherwise.

Definition at line 7414 of file game.cpp.

7415{
7416 popup( _( "This binary was not compiled with tiles support." ) );
7417 return false;
7418}

References _, and popup().

◆ temp_exit_fullscreen()

void game::temp_exit_fullscreen ( )

Definition at line 538 of file game.cpp.

539{
540 if( fullscreen ) {
541 was_fullscreen = true;
543 } else {
544 was_fullscreen = false;
545 }
546}

References fullscreen, toggle_fullscreen(), and was_fullscreen.

Referenced by list_items_monsters(), and look_around().

◆ toggle_debug_hour_timer()

void game::toggle_debug_hour_timer ( )

Definition at line 11728 of file game.cpp.

11729{
11731}

References game::debug_hour_timer::toggle().

Referenced by handle_action(), and look_around().

◆ toggle_fullscreen()

void game::toggle_fullscreen ( )

Definition at line 500 of file game.cpp.

501{
502#if !defined(TILES)
505#else
506 toggle_fullscreen_window();
507#endif
508}

References fullscreen, and mark_main_ui_adaptor_resize().

Referenced by handle_action(), reenter_fullscreen(), and temp_exit_fullscreen().

◆ toggle_pixel_minimap()

void game::toggle_pixel_minimap ( )

Definition at line 510 of file game.cpp.

511{
512#if defined(TILES)
514 clear_window_area( w_pixel_minimap );
515 }
518#endif // TILES
519}

References mark_main_ui_adaptor_resize(), pixel_minimap_option, and w_pixel_minimap.

Referenced by handle_action(), and look_around().

◆ try_get_left_click_action()

bool game::try_get_left_click_action ( action_id act,
const tripoint mouse_target 
)
private

Definition at line 2618 of file game.cpp.

2619{
2620 bool new_destination = true;
2621 if( !destination_preview.empty() ) {
2622 auto &final_destination = destination_preview.back();
2623 if( final_destination.x == mouse_target.x && final_destination.y == mouse_target.y ) {
2624 // Second click
2625 new_destination = false;
2627 destination_preview.clear();
2629 if( act == ACTION_NULL ) {
2630 // Something went wrong
2632 return false;
2633 }
2634 }
2635 }
2636
2637 if( new_destination ) {
2639 u.get_path_avoid() );
2640 return false;
2641 }
2642
2643 return true;
2644}

References act, ACTION_NULL, Character::clear_destination(), destination_preview, Character::get_next_auto_move_direction(), Character::get_path_avoid(), Character::get_pathfinding_settings(), m, Character::pos(), map::route(), Character::set_destination(), u, tripoint::x, and tripoint::y.

Referenced by handle_action().

◆ try_get_right_click_action()

bool game::try_get_right_click_action ( action_id act,
const tripoint mouse_target 
)
private

Definition at line 2646 of file game.cpp.

2647{
2648 const bool cleared_destination = !destination_preview.empty();
2650 destination_preview.clear();
2651
2652 if( cleared_destination ) {
2653 // Produce no-op if auto-move had just been cleared on this action
2654 // e.g. from a previous single left mouse click. This has the effect
2655 // of right-click canceling an auto-move before it is initiated.
2656 return false;
2657 }
2658
2659 const bool is_adjacent = square_dist( mouse_target.xy(), point( u.posx(), u.posy() ) ) <= 1;
2660 const bool is_self = square_dist( mouse_target.xy(), point( u.posx(), u.posy() ) ) <= 0;
2661 if( const monster *const mon = critter_at<monster>( mouse_target ) ) {
2662 if( !u.sees( *mon ) ) {
2663 add_msg( _( "Nothing relevant here." ) );
2664 return false;
2665 }
2666
2667 if( !u.weapon.is_gun() ) {
2668 add_msg( m_info, _( "You are not wielding a ranged weapon." ) );
2669 return false;
2670 }
2671
2672 // TODO: Add weapon range check. This requires weapon to be reloaded.
2673
2674 act = ACTION_FIRE;
2675 } else if( is_adjacent &&
2676 m.close_door( tripoint( mouse_target.xy(), u.posz() ), !m.is_outside( u.pos() ),
2677 true ) ) {
2678 act = ACTION_CLOSE;
2679 } else if( is_self ) {
2681 } else if( is_adjacent ) {
2683 } else {
2684 add_msg( _( "Nothing relevant here." ) );
2685 return false;
2686 }
2687
2688 return true;
2689}
bool close_door(const tripoint &p, bool inside, bool check_only)
Definition: map.cpp:3953
static bool is_adjacent(const monster &z, const Creature &target)

References _, act, ACTION_CLOSE, ACTION_EXAMINE, ACTION_FIRE, ACTION_PICKUP, add_msg(), Character::clear_destination(), map::close_door(), destination_preview, is_adjacent(), item::is_gun(), map::is_outside(), m, m_info, Character::pos(), Character::posx(), Character::posy(), Character::posz(), Character::sees(), square_dist(), u, Character::weapon, and tripoint::xy().

Referenced by handle_action().

◆ unload()

bool game::unload ( item_location  loc)

Definition at line 9018 of file game.cpp.

9019{
9020 return u.unload( loc );
9021}
bool unload(item_location loc)
Definition: player.cpp:2927

References u, and player::unload().

Referenced by inventory_item_menu().

◆ unload_npcs()

void game::unload_npcs ( )
private

Unloads all NPCs.

If you call this you must later call load_npcs, lest caches get rather confused. The tests used to call this a lot when they shouldn't. It is now private to reduce the chance of similar problems in the future.

Definition at line 951 of file game.cpp.

952{
953 for( const auto &npc : active_npc ) {
954 npc->on_unload();
955 }
956
957 active_npc.clear();
958}
void on_unload()
Do some cleanup and caching as npc is being unloaded from map.
Definition: npc.cpp:2642

References active_npc, and npc::on_unload().

Referenced by place_player_overmap(), and reload_npcs().

◆ unserialize()

void game::unserialize ( std::istream &  fin)

Definition at line 167 of file savegame.cpp.

168{
169 chkversion( fin );
170 int tmpturn = 0;
171 int tmpcalstart = 0;
172 int tmprun = 0;
173 tripoint lev;
174 point com;
175 JsonIn jsin( fin );
176 try {
177 JsonObject data = jsin.get_object();
178
179 data.read( "turn", tmpturn );
180 data.read( "calendar_start", tmpcalstart );
182 calendar_config._initial_season = static_cast<season_type>( data.get_int( "initial_season",
183 static_cast<int>( SPRING ) ) );
184 // 0.E stable
185 if( savegame_loading_version < 26 ) {
186 tmpturn *= 6;
187 tmpcalstart *= 6;
188 }
191 tmpcalstart );
192
193 if( !data.read( "game_start", calendar_config._start_of_game ) ) {
195 }
196
197 data.read( "auto_travel_mode", auto_travel_mode );
198 data.read( "run_mode", tmprun );
199 data.read( "mostseen", mostseen );
200 data.read( "levx", lev.x );
201 data.read( "levy", lev.y );
202 data.read( "levz", lev.z );
203 data.read( "om_x", com.x );
204 data.read( "om_y", com.y );
205
206 load_map( tripoint( lev.x + com.x * OMAPX * 2, lev.y + com.y * OMAPY * 2, lev.z ) );
207
208 safe_mode = static_cast<safe_mode_type>( tmprun );
209 if( get_option<bool>( "SAFEMODE" ) && safe_mode == SAFE_MODE_OFF ) {
211 }
212
213 std::string linebuff;
214 std::string linebuf;
215 if( data.read( "grscent", linebuf ) && data.read( "typescent", linebuff ) ) {
216 scent.deserialize( linebuf );
217 scent.deserialize( linebuff, true );
218 } else {
219 scent.reset();
220 }
221 data.read( "active_monsters", *critter_tracker );
222
223 coming_to_stairs.clear();
224 for( auto elem : data.get_array( "stair_monsters" ) ) {
225 monster stairtmp;
226 elem.read( stairtmp );
227 coming_to_stairs.push_back( stairtmp );
228 }
229
230 if( data.has_object( "kill_tracker" ) ) {
231 data.read( "kill_tracker", *kill_tracker_ptr );
232 } else {
233 // Legacy support for when kills were stored directly in game
234 std::map<mtype_id, int> kills;
235 std::vector<std::string> npc_kills;
236 for( const JsonMember member : data.get_object( "kills" ) ) {
237 kills[mtype_id( member.name() )] = member.get_int();
238 }
239
240 for( const std::string npc_name : data.get_array( "npc_kills" ) ) {
241 npc_kills.push_back( npc_name );
242 }
243
244 kill_tracker_ptr->reset( kills, npc_kills );
245 }
246
247 data.read( "player", u );
248 data.read( "stats_tracker", *stats_tracker_ptr );
249 data.read( "achievements_tracker", *achievements_tracker_ptr );
250 data.read( "token_provider", token_provider_ptr );
251 Messages::deserialize( data );
252
253 } catch( const JsonError &jsonerr ) {
254 debugmsg( "Bad save json\n%s", jsonerr.c_str() );
255 return;
256 }
257}
season_type
Real world seasons.
Definition: calendar.h:17
Represents a member of a JsonObject.
Definition: json.h:1249
JsonObject get_object(const std::string &name) const
Definition: json.cpp:361
bool has_object(const std::string &name) const
Definition: json.cpp:425
JsonArray get_array(const std::string &name) const
Definition: json.cpp:332
int get_int(const std::string &name) const
Definition: json.cpp:282
bool read(const std::string &name, T &t, bool throw_on_error=true) const
Definition: json.h:944
void deserialize(const std::string &data, bool is_type=false)
Definition: savegame.cpp:259
safe_mode_type
Definition: game.h:76
static constexpr int OMAPY
static constexpr int OMAPX
Size of the overmap.
void deserialize(const JsonObject &json)
Definition: messages.cpp:330
std::string member
Definition: mapgen.cpp:402
static void chkversion(std::istream &fin)
Definition: savegame.cpp:148
int savegame_loading_version
Definition: savegame.cpp:64

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, achievements_tracker_ptr, auto_travel_mode, JsonError::c_str(), chkversion(), coming_to_stairs, calendar::config, critter_tracker, debugmsg, Messages::deserialize(), scent_map::deserialize(), time_duration::from_turns(), JsonObject::get_array(), JsonObject::get_int(), JsonIn::get_object(), JsonObject::get_object(), JsonObject::has_object(), kill_tracker_ptr, load_map(), mapgen_defer::member, mostseen, mtype_id, OMAPX, OMAPY, JsonObject::read(), scent_map::reset(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, savegame_loading_version, scent, SPRING, stats_tracker_ptr, token_provider_ptr, calendar::turn, calendar::turn_zero, u, point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

Referenced by load().

◆ unserialize_master()

void game::unserialize_master ( std::istream &  fin)

Definition at line 1188 of file savegame.cpp.

1189{
1191 chkversion( fin );
1192 if( savegame_loading_version < 11 ) {
1193 std::unique_ptr<static_popup>popup = std::make_unique<static_popup>();
1194 popup->message(
1195 _( "Cannot find loader for save data in old version %d, attempting to load as current version %d." ),
1199 }
1200 try {
1201 // single-pass parsing example
1202 JsonIn jsin( fin );
1203 jsin.start_object();
1204 while( !jsin.end_object() ) {
1205 std::string name = jsin.get_member_name();
1206 if( name == "next_mission_id" ) {
1207 next_mission_id = jsin.get_int();
1208 } else if( name == "next_npc_id" ) {
1209 next_npc_id.deserialize( jsin );
1210 } else if( name == "active_missions" ) {
1212 } else if( name == "factions" ) {
1213 jsin.read( *faction_manager_ptr );
1214 } else if( name == "seed" ) {
1215 jsin.read( seed );
1216 } else if( name == "weather" ) {
1217 JsonObject w = jsin.get_object();
1218 w.read( "lightning", get_weather().lightning_active );
1219 } else {
1220 // silently ignore anything else
1221 jsin.skip_value();
1222 }
1223 }
1224 } catch( const JsonError &e ) {
1225 debugmsg( "error loading %s: %s", SAVE_MASTER, e.c_str() );
1226 }
1227}
void deserialize(JsonIn &)
static void unserialize_all(JsonIn &jsin)
Definition: savegame.cpp:1178

References _, JsonError::c_str(), chkversion(), debugmsg, character_id::deserialize(), JsonIn::end_object(), faction_manager_ptr, JsonIn::get_int(), JsonIn::get_member_name(), JsonIn::get_object(), get_weather, om_direction::name(), next_mission_id, next_npc_id, popup(), JsonIn::read(), JsonObject::read(), ui_manager::redraw(), refresh_display(), SAVE_MASTER(), savegame_loading_version, savegame_version, seed, JsonIn::skip_value(), JsonIn::start_object(), and mission::unserialize_all().

Referenced by load_master().

◆ update_map() [1/2]

point game::update_map ( int &  x,
int &  y 
)

Definition at line 11188 of file game.cpp.

11189{
11190 point shift;
11191
11192 while( x < HALF_MAPSIZE_X ) {
11193 x += SEEX;
11194 shift.x--;
11195 }
11196 while( x >= HALF_MAPSIZE_X + SEEX ) {
11197 x -= SEEX;
11198 shift.x++;
11199 }
11200 while( y < HALF_MAPSIZE_Y ) {
11201 y += SEEY;
11202 shift.y--;
11203 }
11204 while( y >= HALF_MAPSIZE_Y + SEEY ) {
11205 y -= SEEY;
11206 shift.y++;
11207 }
11208
11209 if( shift == point_zero ) {
11210 // adjust player position
11211 u.setpos( tripoint( x, y, get_levz() ) );
11212 // Update what parts of the world map we can see
11213 // We need this call because even if the map hasn't shifted we may have changed z-level and can now see farther
11214 // TODO: only make this call if we changed z-level
11216 // Not actually shifting the submaps, all the stuff below would do nothing
11217 return point_zero;
11218 }
11219
11220 // this handles loading/unloading submaps that have scrolled on or off the viewport
11221 // NOLINTNEXTLINE(cata-use-named-point-constants)
11222 inclusive_rectangle<point> size_1( point( -1, -1 ), point( 1, 1 ) );
11223 point remaining_shift = shift;
11224 while( remaining_shift != point_zero ) {
11225 point this_shift = clamp( remaining_shift, size_1 );
11226 m.shift( this_shift );
11227 remaining_shift -= this_shift;
11228 }
11229
11230 grid_tracker_ptr->load( m );
11231
11232 // Shift monsters
11233 shift_monsters( tripoint( shift, 0 ) );
11234 const point shift_ms = sm_to_ms_copy( shift );
11235 u.shift_destination( -shift_ms );
11236
11237 // Shift NPCs
11238 for( auto it = active_npc.begin(); it != active_npc.end(); ) {
11239 ( *it )->shift( shift );
11240 if( ( *it )->posx() < 0 - SEEX * 2 || ( *it )->posy() < 0 - SEEX * 2 ||
11241 ( *it )->posx() > SEEX * ( MAPSIZE + 2 ) || ( *it )->posy() > SEEY * ( MAPSIZE + 2 ) ) {
11242 //Remove the npc from the active list. It remains in the overmap list.
11243 ( *it )->on_unload();
11244 it = active_npc.erase( it );
11245 } else {
11246 it++;
11247 }
11248 }
11249
11250 scent.shift( shift_ms );
11251
11252 // Also ensure the player is on current z-level
11253 // get_levz() should later be removed, when there is no longer such a thing
11254 // as "current z-level"
11255 u.setpos( tripoint( x, y, get_levz() ) );
11256
11257 // Only do the loading after all coordinates have been shifted.
11258
11259 // Check for overmap saved npcs that should now come into view.
11260 // Put those in the active list.
11261 load_npcs();
11262
11263 // Make sure map cache is consistent since it may have shifted.
11264 if( m.has_zlevels() ) {
11265 for( int zlev = -OVERMAP_DEPTH; zlev <= OVERMAP_HEIGHT; ++zlev ) {
11266 m.invalidate_map_cache( zlev );
11267 }
11268 } else {
11270 }
11272
11273 // Spawn monsters if appropriate
11274 // This call will generate new monsters in addition to loading, so it's placed after NPC loading
11275 m.spawn_monsters( false ); // Static monsters
11276
11277 // Update what parts of the world map we can see
11279
11280 return shift;
11281}
void shift_destination(const point &shift)
void shift_monsters(const tripoint &shift)
Shift all active monsters, the shift vector is the number of shifted submaps.
Definition: game.cpp:11557
void shift(const point &s)
Shift the map along the vector s.
Definition: map.cpp:6648
void shift(const point &sm_shift)
Definition: scent_map.cpp:82
point sm_to_ms_copy(const point &p)
static constexpr int HALF_MAPSIZE_Y
static constexpr int HALF_MAPSIZE_X

References active_npc, map::build_map_cache(), clamp(), get_levz(), grid_tracker_ptr, HALF_MAPSIZE_X, HALF_MAPSIZE_Y, map::has_zlevels(), map::invalidate_map_cache(), load_npcs(), m, MAPSIZE, OVERMAP_DEPTH, OVERMAP_HEIGHT, point_zero, scent, SEEX, SEEY, Character::setpos(), map::shift(), scent_map::shift(), Character::shift_destination(), shift_monsters(), sm_to_ms_copy(), map::spawn_monsters(), u, update_overmap_seen(), point::x, and point::y.

◆ update_map() [2/2]

point game::update_map ( player p)

Definition at line 11182 of file game.cpp.

11183{
11184 point p2( p.posx(), p.posy() );
11185 return update_map( p2.x, p2.y );
11186}

References Character::posx(), Character::posy(), update_map(), point::x, and point::y.

Referenced by fling_creature(), load(), place_player(), start_game(), update_map(), and vertical_move().

◆ update_overmap_seen()

void game::update_overmap_seen ( )

Definition at line 11283 of file game.cpp.

11284{
11285 const tripoint_abs_omt ompos = u.global_omt_location();
11286 const int dist = u.overmap_sight_range( light_level( u.posz() ) );
11287 const int dist_squared = dist * dist;
11288 // We can always see where we're standing
11289 overmap_buffer.set_seen( ompos, true );
11290 for( const tripoint_abs_omt &p : points_in_radius( ompos, dist ) ) {
11291 const point_rel_omt delta = p.xy() - ompos.xy();
11292 const int h_squared = delta.x() * delta.x() + delta.y() * delta.y();
11293 if( trigdist && h_squared > dist_squared ) {
11294 continue;
11295 }
11296 if( delta == point_rel_omt() ) {
11297 // 1. This case is already handled outside of the loop
11298 // 2. Calculating multiplier would cause division by zero
11299 continue;
11300 }
11301 // If circular distances are enabled, scale overmap distances by the diagonality of the sight line.
11302 point abs_delta = delta.raw().abs();
11303 int max_delta = std::max( abs_delta.x, abs_delta.y );
11304 const float multiplier = trigdist ? std::sqrt( h_squared ) / max_delta : 1;
11305 const std::vector<tripoint_abs_omt> line = line_to( ompos, p );
11306 float sight_points = dist;
11307 for( auto it = line.begin();
11308 it != line.end() && sight_points >= 0; ++it ) {
11309 const oter_id &ter = overmap_buffer.ter( *it );
11310 sight_points -= static_cast<int>( ter->get_see_cost() ) * multiplier;
11311 }
11312 if( sight_points >= 0 ) {
11313 tripoint_abs_omt seen( p );
11314 do {
11315 overmap_buffer.set_seen( seen, true );
11316 --seen.z();
11317 } while( seen.z() >= 0 );
11318 }
11319 }
11320}
bool trigdist
Circular distances.
int overmap_sight_range(int light_level) const
Returns the distance the player can see on the overmap.
Definition: character.cpp:771
constexpr Point & raw()
Definition: coordinates.h:111
void set_seen(const tripoint_abs_omt &p, bool seen=true)
coords::coord_point< point, coords::origin::relative, coords::omt > point_rel_omt
Definition: coordinates.h:478
tripoint_range< Tripoint > points_in_radius(const Tripoint &center, const int radius, const int radiusz=0)
Definition: map_iterator.h:125
unsigned char get_see_cost() const
Definition: omdata.h:230

References oter_t::get_see_cost(), Character::global_omt_location(), light_level(), line(), line_to(), overmap_buffer, Character::overmap_sight_range(), points_in_radius(), Character::posz(), coords::coord_point< Point, Origin, Scale >::raw(), overmapbuffer::set_seen(), overmapbuffer::ter(), trigdist, u, coords::coord_point< Point, Origin, Scale >::x(), point::x, coords::coord_point< Point, Origin, Scale >::xy(), coords::coord_point< Point, Origin, Scale >::y(), point::y, and coords::coord_point< Point, Origin, Scale >::z().

Referenced by place_player_overmap(), and update_map().

◆ update_stair_monsters()

void game::update_stair_monsters ( )
private
Dodge reduces chance of being downed when pushed off the stairs

Definition at line 11335 of file game.cpp.

11336{
11337 // Search for the stairs closest to the player.
11338 std::vector<int> stairx;
11339 std::vector<int> stairy;
11340 std::vector<int> stairdist;
11341
11342 const bool from_below = monstairz < get_levz();
11343
11344 if( coming_to_stairs.empty() ) {
11345 return;
11346 }
11347
11348 if( m.has_zlevels() ) {
11349 debugmsg( "%d monsters coming to stairs on a map with z-levels",
11350 coming_to_stairs.size() );
11351 coming_to_stairs.clear();
11352 }
11353
11354 for( const tripoint &dest : m.points_on_zlevel( u.posz() ) ) {
11355 if( ( from_below && m.has_flag( "GOES_DOWN", dest ) ) ||
11356 ( !from_below && m.has_flag( "GOES_UP", dest ) ) ) {
11357 stairx.push_back( dest.x );
11358 stairy.push_back( dest.y );
11359 stairdist.push_back( rl_dist( dest, u.pos() ) );
11360 }
11361 }
11362 if( stairdist.empty() ) {
11363 return; // Found no stairs?
11364 }
11365
11366 // Find closest stairs.
11367 size_t si = 0;
11368 for( size_t i = 0; i < stairdist.size(); i++ ) {
11369 if( stairdist[i] < stairdist[si] ) {
11370 si = i;
11371 }
11372 }
11373
11374 // Find up to 4 stairs for distance stairdist[si] +1
11375 std::vector<int> nearest;
11376 nearest.push_back( si );
11377 for( size_t i = 0; i < stairdist.size() && nearest.size() < 4; i++ ) {
11378 if( ( i != si ) && ( stairdist[i] <= stairdist[si] + 1 ) ) {
11379 nearest.push_back( i );
11380 }
11381 }
11382 // Randomize the stair choice
11383 si = random_entry_ref( nearest );
11384
11385 // Attempt to spawn zombies.
11386 for( size_t i = 0; i < coming_to_stairs.size(); i++ ) {
11387 point mpos( stairx[si], stairy[si] );
11388 monster &critter = coming_to_stairs[i];
11389 const tripoint dest {
11390 mpos, g->get_levz()
11391 };
11392
11393 // We might be not be visible.
11394 if( ( critter.posx() < 0 - ( MAPSIZE_X ) / 6 ||
11395 critter.posy() < 0 - ( MAPSIZE_Y ) / 6 ||
11396 critter.posx() > ( MAPSIZE_X * 7 ) / 6 ||
11397 critter.posy() > ( MAPSIZE_Y * 7 ) / 6 ) ) {
11398 continue;
11399 }
11400
11401 critter.staircount -= 4;
11402 // Let the player know zombies are trying to come.
11403 if( u.sees( dest ) ) {
11404 std::string dump;
11405 if( critter.staircount > 4 ) {
11406 dump += string_format( _( "You see a %s on the stairs" ), critter.name() );
11407 } else {
11408 if( critter.staircount > 0 ) {
11409 dump += ( from_below ?
11410 //~ The <monster> is almost at the <bottom/top> of the <terrain type>!
11411 string_format( _( "The %1$s is almost at the top of the %2$s!" ),
11412 critter.name(),
11413 m.tername( dest ) ) :
11414 string_format( _( "The %1$s is almost at the bottom of the %2$s!" ),
11415 critter.name(),
11416 m.tername( dest ) ) );
11417 }
11418 }
11419
11420 add_msg( m_warning, dump );
11421 } else {
11423 _( "a sound nearby from the stairs!" ), true, "misc", "stairs_movement" );
11424 }
11425
11426 if( critter.staircount > 0 ) {
11427 continue;
11428 }
11429
11430 if( is_empty( dest ) ) {
11431 critter.spawn( dest );
11432 critter.staircount = 0;
11433 place_critter_at( make_shared_fast<monster>( critter ), dest );
11434 if( u.sees( dest ) ) {
11435 if( !from_below ) {
11436 add_msg( m_warning, _( "The %1$s comes down the %2$s!" ),
11437 critter.name(),
11438 m.tername( dest ) );
11439 } else {
11440 add_msg( m_warning, _( "The %1$s comes up the %2$s!" ),
11441 critter.name(),
11442 m.tername( dest ) );
11443 }
11444 }
11445 coming_to_stairs.erase( coming_to_stairs.begin() + i );
11446 continue;
11447 } else if( u.pos() == dest ) {
11448 // Monster attempts to push player of stairs
11450 int tries = 0;
11451
11452 // the critter is now right on top of you and will attack unless
11453 // it can find a square to push you into with one of his tries.
11454 const int creature_push_attempts = 9;
11455 const int player_throw_resist_chance = 3;
11456
11457 critter.spawn( dest );
11458 while( tries < creature_push_attempts ) {
11459 tries++;
11460 push.x = rng( -1, 1 );
11461 push.y = rng( -1, 1 );
11462 point ipos( mpos + push );
11463 tripoint pos( ipos, get_levz() );
11464 if( ( push.x != 0 || push.y != 0 ) && !critter_at( pos ) &&
11465 critter.can_move_to( pos ) ) {
11466 bool resiststhrow = ( u.is_throw_immune() ) ||
11468 if( resiststhrow && one_in( player_throw_resist_chance ) ) {
11469 u.moves -= 25; // small charge for avoiding the push altogether
11470 add_msg( _( "The %s fails to push you back!" ),
11471 critter.name() );
11472 return; //judo or leg brace prevent you from getting pushed at all
11473 }
11474 // Not accounting for tentacles latching on, so..
11475 // Something is about to happen, lets charge half a move
11476 u.moves -= 50;
11477 if( resiststhrow && ( u.is_throw_immune() ) ) {
11478 //we have a judoka who isn't getting pushed but counterattacking now.
11479 mattack::thrown_by_judo( &critter );
11480 return;
11481 }
11482 std::string msg;
11483 ///\EFFECT_DODGE reduces chance of being downed when pushed off the stairs
11484 if( !( resiststhrow ) && ( u.get_dodge() + rng( 0, 3 ) < 12 ) ) {
11485 // dodge 12 - never get downed
11486 // 11.. avoid 75%; 10.. avoid 50%; 9.. avoid 25%
11487 u.add_effect( effect_downed, 2_turns );
11488 msg = _( "The %s pushed you back hard!" );
11489 } else {
11490 msg = _( "The %s pushed you back!" );
11491 }
11492 add_msg( m_warning, msg.c_str(), critter.name() );
11493 u.setx( u.posx() + push.x );
11494 u.sety( u.posy() + push.y );
11495 return;
11496 }
11497 }
11499 _( "The %s tried to push you back but failed! It attacks you!" ),
11500 critter.name() );
11501 critter.melee_attack( u );
11502 u.moves -= 50;
11503 return;
11504 } else if( monster *const mon_ptr = critter_at<monster>( dest ) ) {
11505 // Monster attempts to displace a monster from the stairs
11506 monster &other = *mon_ptr;
11507 critter.spawn( dest );
11508
11509 // the critter is now right on top of another and will push it
11510 // if it can find a square to push it into inside of his tries.
11511 const int creature_push_attempts = 9;
11512 const int creature_throw_resist = 4;
11513
11514 int tries = 0;
11515 point push2;
11516 while( tries < creature_push_attempts ) {
11517 tries++;
11518 push2.x = rng( -1, 1 );
11519 push2.y = rng( -1, 1 );
11520 point ipos2( mpos + push2 );
11521 tripoint pos( ipos2, get_levz() );
11522 if( ( push2.x == 0 && push2.y == 0 ) || ( ( ipos2.x == u.posx() ) && ( ipos2.y == u.posy() ) ) ) {
11523 continue;
11524 }
11525 if( !critter_at( pos ) && other.can_move_to( pos ) ) {
11526 other.setpos( tripoint( ipos2, get_levz() ) );
11527 other.moves -= 50;
11528 std::string msg;
11529 if( one_in( creature_throw_resist ) ) {
11530 other.add_effect( effect_downed, 2_turns );
11531 msg = _( "The %1$s pushed the %2$s hard." );
11532 } else {
11533 msg = _( "The %1$s pushed the %2$s." );
11534 }
11535 add_msg( m_neutral, msg, critter.name(), other.name() );
11536 return;
11537 }
11538 }
11539 return;
11540 }
11541 }
11542}
void setx(int x)
Definition: character.h:790
void sety(int y)
Definition: character.h:793
bool is_throw_immune() const
Returns true if the player is immune to throws.
float get_dodge() const override
Definition: melee.cpp:782
int monstairz
Definition: game.h:1032
tripoint_range< tripoint > points_on_zlevel() const
Yields a range of all points that are contained in the map and have the z-level of this map (abs_sub)...
Definition: map.cpp:8443
bool can_move_to(const tripoint &p) const
Checks whether we can move to/through p.
Definition: monmove.cpp:249
int posy() const override
Definition: monster.h:498
void melee_attack(Creature &target)
Definition: monster.cpp:1370
int staircount
Definition: monster.h:509
void spawn(const tripoint &p)
Definition: monster.cpp:481
int posx() const override
Definition: monster.h:495
bool thrown_by_judo(monster *z)
Definition: monattack.cpp:4581
std::enable_if<!is_std_array< C >::value, constV & >::type random_entry_ref(const C &container)
Same as above, but with a statically allocated default value (using the default constructor).
Definition: rng.h:149

References _, Creature::add_effect(), add_msg(), monster::can_move_to(), coming_to_stairs, critter_at(), debugmsg, effect_downed, g, Character::get_dodge(), get_levz(), map::has_flag(), Character::has_trait(), map::has_zlevels(), is_empty(), Character::is_throw_immune(), m, m_neutral, m_warning, MAPSIZE_X, MAPSIZE_Y, monster::melee_attack(), monstairz, sounds::movement, Creature::moves, monster::name(), one_in(), other, place_critter_at(), point_north_west, map::points_on_zlevel(), Character::pos(), Character::posx(), monster::posx(), Character::posy(), monster::posy(), Character::posz(), monexamine::push(), random_entry_ref(), rl_dist(), rng(), Character::sees(), Character::setx(), Character::sety(), sounds::sound(), monster::spawn(), monster::staircount, string_format(), map::tername(), mattack::thrown_by_judo(), trait_LEG_TENT_BRACE, u, point::x, and point::y.

Referenced by do_turn(), and vertical_move().

◆ update_zombie_pos()

bool game::update_zombie_pos ( const monster critter,
const tripoint pos 
)

Redirects to the creature_tracker update_pos() function.

Definition at line 5033 of file game.cpp.

5034{
5035 return critter_tracker->update_pos( critter, pos );
5036}

References critter_tracker.

◆ use_computer()

void game::use_computer ( const tripoint p)

Checks to see if a player can use a computer (not illiterate, etc.) and uses if able.

Definition at line 4816 of file game.cpp.

4817{
4818 if( u.has_trait( trait_id( "ILLITERATE" ) ) ) {
4819 add_msg( m_info, _( "You can not read a computer screen!" ) );
4820 return;
4821 }
4822 if( u.is_blind() ) {
4823 // we don't have screen readers in game
4824 add_msg( m_info, _( "You can not see a computer screen!" ) );
4825 return;
4826 }
4827 if( u.has_trait( trait_id( "HYPEROPIC" ) ) && !u.worn_with_flag( "FIX_FARSIGHT" ) &&
4828 !u.has_effect( effect_contacts ) && !u.has_bionic( bionic_id( "bio_eye_optic" ) ) ) {
4829 add_msg( m_info, _( "You'll need to put on reading glasses before you can see the screen." ) );
4830 return;
4831 }
4832
4833 computer *used = m.computer_at( p );
4834
4835 if( used == nullptr ) {
4836 if( m.has_flag( "CONSOLE", p ) ) { //Console without map data
4837 add_msg( m_bad, _( "The console doesn't display anything coherent." ) );
4838 } else {
4839 debugmsg( "Tried to use computer at %s - none there", p.to_string() );
4840 }
4841 return;
4842 }
4843
4844 computer_session( *used ).use();
4845}
void use()
Handles player use of a computer.
computer * computer_at(const tripoint &p)
Definition: map.cpp:5520
static const efftype_id effect_contacts("contacts")

References _, add_msg(), map::computer_at(), debugmsg, effect_contacts, Character::has_bionic(), Creature::has_effect(), map::has_flag(), Character::has_trait(), Character::is_blind(), m, m_bad, m_info, tripoint::to_string(), u, computer_session::use(), and Character::worn_with_flag().

Referenced by examine().

◆ validate_camps()

void game::validate_camps ( )

validate camps to ensure they are on the overmap list

Definition at line 2038 of file game.cpp.

2039{
2040 basecamp camp = m.hoist_submap_camp( u.pos() );
2041 if( camp.is_valid() ) {
2042 overmap_buffer.add_camp( camp );
2044 } else if( camp.camp_omt_pos() != tripoint_abs_omt() ) {
2045 std::string camp_name = _( "Faction Camp" );
2046 camp.set_name( camp_name );
2047 overmap_buffer.add_camp( camp );
2049 }
2050}
bool is_valid() const
Definition: basecamp.h:125
void set_name(const std::string &new_name)
Definition: basecamp.cpp:575
tripoint_abs_omt camp_omt_pos() const
Definition: basecamp.h:134
basecamp hoist_submap_camp(const tripoint &p)
Definition: map.cpp:5551
void remove_submap_camp(const tripoint &)
Definition: map.cpp:5546
void add_camp(const basecamp &camp)
Add Basecamp to overmapbuffer.

References _, overmapbuffer::add_camp(), basecamp::camp_omt_pos(), map::hoist_submap_camp(), basecamp::is_valid(), m, overmap_buffer, Character::pos(), map::remove_submap_camp(), basecamp::set_name(), and u.

Referenced by load().

◆ validate_linked_vehicles()

void game::validate_linked_vehicles ( )

validate towed vehicles so they get linked up again after a load

Definition at line 1980 of file game.cpp.

1981{
1982 for( auto &veh : m.get_vehicles() ) {
1983 vehicle *v = veh.v;
1986 if( other_v ) {
1987 // the other vehicle is towing us.
1988 v->tow_data.set_towing( other_v, v );
1990 }
1991 }
1992 }
1993}
tripoint other_towing_point
Definition: vehicle.h:167
bool set_towing(vehicle *tower_veh, vehicle *towed_veh)
Definition: vehicle.cpp:5940
towing_data tow_data
Definition: vehicle.h:1924

References map::get_vehicles(), m, towing_data::other_towing_point, towing_data::set_towing(), vehicle::tow_data, tripoint_zero, map::veh_at(), and veh_pointer_or_null().

Referenced by load().

◆ validate_mounted_npcs()

void game::validate_mounted_npcs ( )

Definition at line 1995 of file game.cpp.

1996{
1997 for( monster &m : all_monsters() ) {
1998 if( m.has_effect( effect_ridden ) && m.mounted_player_id.is_valid() ) {
1999 player *mounted_pl = g->critter_by_id<player>( m.mounted_player_id );
2000 if( !mounted_pl ) {
2001 // Target no longer valid.
2002 m.mounted_player_id = character_id();
2003 m.remove_effect( effect_ridden );
2004 continue;
2005 }
2006 mounted_pl->mounted_creature = shared_from( m );
2007 mounted_pl->setpos( m.pos() );
2008 mounted_pl->add_effect( effect_riding, 1_turns, num_bp );
2009 m.mounted_player = mounted_pl;
2010 }
2011 }
2012}

References Creature::add_effect(), all_monsters(), character_id, effect_ridden, effect_riding, g, m, Character::mounted_creature, num_bp, Character::setpos(), and shared_from().

Referenced by load(), and vertical_shift().

◆ validate_npc_followers()

void game::validate_npc_followers ( )

validate list of followers to account for overmap buffers

Definition at line 2014 of file game.cpp.

2015{
2016 // Make sure visible followers are in the list.
2017 const std::vector<npc *> visible_followers = get_npcs_if( [&]( const npc & guy ) {
2018 return guy.is_player_ally();
2019 } );
2020 for( npc *guy : visible_followers ) {
2021 update_faction_api( guy );
2022 add_npc_follower( guy->getID() );
2023 }
2024 // Make sure overmapbuffered NPC followers are in the list.
2025 for( const auto &temp_guy : overmap_buffer.get_npcs_near_player( 300 ) ) {
2026 npc *guy = temp_guy.get();
2027 if( guy->is_player_ally() ) {
2028 update_faction_api( guy );
2029 add_npc_follower( guy->getID() );
2030 }
2031 }
2032 // Make sure that serialized player followers sync up with game list
2033 for( const auto &temp_id : u.follower_ids ) {
2034 add_npc_follower( temp_id );
2035 }
2036}
void add_npc_follower(const character_id &id)
Add follower id to set of followers.
Definition: game.cpp:1960
static void update_faction_api(npc *guy)
Definition: game.cpp:1972

References add_npc_follower(), player::follower_ids, get_npcs_if(), overmapbuffer::get_npcs_near_player(), Character::getID(), npc::is_player_ally(), overmap_buffer, u, and update_faction_api().

Referenced by load().

◆ vertical_move()

void game::vertical_move ( int  z,
bool  force,
bool  peeking = false 
)

Moves the player vertically.

If force == true then they are falling. If peeking == true, forbids some exotic movement options

Strength increases breath-holding capacity while diving Dexterity increases chance of moving past monsters on stairs Dodge increases chance of moving past monsters on stairs Strength increases chance of moving past monsters on stairs Melee increases chance of moving past monsters on stairs

Definition at line 10509 of file game.cpp.

10510{
10511 if( u.is_mounted() ) {
10512 auto mons = u.mounted_creature.get();
10513 if( mons->has_flag( MF_RIDEABLE_MECH ) ) {
10514 if( !mons->check_mech_powered() ) {
10515 add_msg( m_bad, _( "Your %s refuses to move as its batteries have been drained." ),
10516 mons->get_name() );
10517 return;
10518 }
10519 }
10520 }
10521
10522 // > and < are used for diving underwater.
10523 if( m.has_flag( "SWIMMABLE", u.pos() ) && m.has_flag( TFLAG_DEEP_WATER, u.pos() ) ) {
10524 if( movez == -1 ) {
10525 if( u.is_underwater() ) {
10526 add_msg( m_info, _( "You are already underwater!" ) );
10527 return;
10528 }
10529 if( u.worn_with_flag( "FLOTATION" ) ) {
10530 add_msg( m_info, _( "You can't dive while wearing a flotation device." ) );
10531 return;
10532 }
10533 u.set_underwater( true );
10534 ///\EFFECT_STR increases breath-holding capacity while diving
10535 u.oxygen = 30 + 2 * u.str_cur;
10536 add_msg( _( "You dive underwater!" ) );
10537 } else {
10538 if( u.swim_speed() < 500 || u.shoe_type_count( itype_swim_fins ) ) {
10539 u.set_underwater( false );
10540 add_msg( _( "You surface." ) );
10541 } else {
10542 add_msg( m_info, _( "You try to surface but can't!" ) );
10543 }
10544 }
10545 u.moves -= 100;
10546 return;
10547 }
10548
10549 // Force means we're going down, even if there's no staircase, etc.
10550 bool climbing = false;
10551 int move_cost = 100;
10552 tripoint stairs( u.posx(), u.posy(), u.posz() + movez );
10553 if( m.has_zlevels() && !force && movez == 1 && !m.has_flag( "GOES_UP", u.pos() ) ) {
10554 // Climbing
10555 if( m.has_floor_or_support( stairs ) ) {
10556 add_msg( m_info, _( "You can't climb here - there's a ceiling above your head." ) );
10557 return;
10558 }
10559
10560 std::vector<tripoint> pts;
10561 for( const auto &pt : m.points_in_radius( stairs, 1 ) ) {
10562 if( m.passable( pt ) &&
10563 m.has_floor_or_support( pt ) ) {
10564 pts.push_back( pt );
10565 }
10566 }
10567
10568 const int cost = map_funcs::climbing_cost( m, u.pos(), stairs );
10569
10570 if( cost == 0 ) {
10571 if( u.has_trait( trait_WEB_ROPE ) ) {
10572 if( pts.empty() ) {
10573 add_msg( m_info, _( "There is nothing above you that you can attach a web to." ) );
10574 } else if( can_use_mutation_warn( trait_WEB_ROPE, u ) ) {
10575 if( g->m.move_cost( u.pos() ) != 2 && g->m.move_cost( u.pos() ) != 3 ) {
10576 add_msg( m_info, _( "You can't spin a web rope there." ) );
10577 } else if( g->m.has_furn( u.pos() ) ) {
10578 add_msg( m_info, _( "There is already furniture at that location." ) );
10579 } else {
10580 if( query_yn( "Spin a rope and climb?" ) ) {
10581 add_msg( m_good, _( "You spin a rope of web." ) );
10582 g->m.furn_set( u.pos(), furn_str_id( "f_rope_up_web" ) );
10583 u.mod_moves( to_turns<int>( 2_seconds ) );
10585 vertical_move( movez, force, peeking );
10586 }
10587 }
10588 }
10589
10590 } else {
10591 add_msg( m_info, _( "You can't climb here - you need walls and/or furniture to brace against." ) );
10592
10593 }
10594 return;
10595
10596 }
10597
10598 if( cost <= 0 || pts.empty() ) {
10599 add_msg( m_info,
10600 _( "You can't climb here - there is no terrain above you that would support your weight." ) );
10601 return;
10602 } else {
10603 // TODO: Make it an extended action
10604 climbing = true;
10605 move_cost = cost;
10606
10608 if( !pnt ) {
10609 return;
10610 }
10611 stairs = *pnt;
10612 }
10613 }
10614
10615 if( !force && movez == -1 && !m.has_flag( "GOES_DOWN", u.pos() ) ) {
10616 add_msg( m_info, _( "You can't go down here!" ) );
10617 return;
10618 } else if( !climbing && !force && movez == 1 && !m.has_flag( "GOES_UP", u.pos() ) ) {
10619 add_msg( m_info, _( "You can't go up here!" ) );
10620 return;
10621 }
10622
10623 if( force ) {
10624 // Let go of a grabbed cart.
10625 u.grab( OBJECT_NONE );
10626 } else if( u.grab_point != tripoint_zero ) {
10627 add_msg( m_info, _( "You can't drag things up and down stairs." ) );
10628 return;
10629 }
10630
10631 // Because get_levz takes z-value from the map, it will change when vertical_shift (m.has_zlevels() == true)
10632 // is called or when the map is loaded on new z-level (== false).
10633 // This caches the z-level we start the movement on (current) and the level we're want to end.
10634 const int z_before = get_levz();
10635 const int z_after = get_levz() + movez;
10636 if( z_after < -OVERMAP_DEPTH || z_after > OVERMAP_HEIGHT ) {
10637 debugmsg( "Tried to move outside allowed range of z-levels" );
10638 return;
10639 }
10640
10641 if( !u.move_effects( false ) ) {
10642 return;
10643 }
10644
10645 // Check if there are monsters are using the stairs.
10646 bool slippedpast = false;
10647 if( !m.has_zlevels() && !coming_to_stairs.empty() && !force ) {
10648 // TODO: Allow travel if zombie couldn't reach stairs, but spawn him when we go up.
10649 add_msg( m_warning, _( "You try to use the stairs. Suddenly you are blocked by a %s!" ),
10650 coming_to_stairs[0].name() );
10651 // Roll.
10652 ///\EFFECT_DEX increases chance of moving past monsters on stairs
10653
10654 ///\EFFECT_DODGE increases chance of moving past monsters on stairs
10655 int dexroll = dice( 6, u.dex_cur + u.get_skill_level( skill_dodge ) * 2 );
10656 ///\EFFECT_STR increases chance of moving past monsters on stairs
10657
10658 ///\EFFECT_MELEE increases chance of moving past monsters on stairs
10659 int strroll = dice( 3, u.str_cur + u.get_skill_level( skill_melee ) * 1.5 );
10660 if( coming_to_stairs.size() > 4 ) {
10661 add_msg( _( "The are a lot of them on the %s!" ), m.tername( u.pos() ) );
10662 dexroll /= 4;
10663 strroll /= 2;
10664 } else if( coming_to_stairs.size() > 1 ) {
10665 add_msg( m_warning, _( "There's something else behind it!" ) );
10666 dexroll /= 2;
10667 }
10668
10669 if( dexroll < 14 || strroll < 12 ) {
10671 u.moves -= 100;
10672 return;
10673 }
10674
10675 add_msg( _( "You manage to slip past!" ) );
10676 slippedpast = true;
10677 u.moves -= 100;
10678 }
10679
10680 // Shift the map up or down
10681
10682 std::unique_ptr<map> tmp_map_ptr;
10683 if( !m.has_zlevels() ) {
10684 tmp_map_ptr = std::make_unique<map>();
10685 }
10686
10687 map &maybetmp = m.has_zlevels() ? m : *( tmp_map_ptr.get() );
10688 if( m.has_zlevels() ) {
10689 // We no longer need to shift the map here! What joy
10690 } else {
10691 maybetmp.load( tripoint( get_levx(), get_levy(), z_after ), false );
10692 }
10693
10694 // Find the corresponding staircase
10695 bool rope_ladder = false;
10696 // TODO: Remove the stairfinding, make the mapgen gen aligned maps
10697 if( !force && !climbing ) {
10698 const cata::optional<tripoint> pnt = find_or_make_stairs( maybetmp, z_after, rope_ladder, peeking );
10699 if( !pnt ) {
10700 return;
10701 }
10702 stairs = *pnt;
10703 }
10704
10705 if( !force ) {
10706 monstairz = z_before;
10707 }
10708 // Save all monsters that can reach the stairs, remove them from the tracker,
10709 // then despawn the remaining monsters. Because it's a vertical shift, all
10710 // monsters are out of the bounds of the map and will despawn.
10711 shared_ptr_fast<monster> stored_mount;
10712 if( u.is_mounted() && !m.has_zlevels() ) {
10713 // Store a *copy* of the mount, so we can remove the original monster instance
10714 // from the tracker before the map shifts.
10715 // Map shifting would otherwise just despawn the mount and would later respawn it.
10716 stored_mount = make_shared_fast<monster>( *u.mounted_creature );
10718 }
10719 if( !m.has_zlevels() ) {
10720 const tripoint to = u.pos();
10721 for( monster &critter : all_monsters() ) {
10722 // if its a ladder instead of stairs - most zombies can't climb that.
10723 // unless that have a special flag to allow them to do so.
10724 if( ( m.has_flag( "DIFFICULT_Z", u.pos() ) && !critter.climbs() ) ||
10725 critter.has_effect( effect_ridden ) ||
10726 critter.has_effect( effect_tied ) ) {
10727 continue;
10728 }
10729 int turns = critter.turns_to_reach( to.xy() );
10730 if( turns < 10 && coming_to_stairs.size() < 8 && critter.will_reach( to.xy() )
10731 && !slippedpast ) {
10732 critter.staircount = 10 + turns;
10733 critter.on_unload();
10734 coming_to_stairs.push_back( critter );
10735 remove_zombie( critter );
10736 }
10737 }
10738 auto mons = critter_tracker->find( g->u.pos() );
10739 if( mons != nullptr ) {
10740 critter_tracker->remove( *mons );
10741 }
10742 shift_monsters( tripoint( 0, 0, movez ) );
10743 }
10744
10745 std::vector<shared_ptr_fast<npc>> npcs_to_bring;
10746 std::vector<monster *> monsters_following;
10747 if( !m.has_zlevels() && std::abs( movez ) == 1 ) {
10748 std::copy_if( active_npc.begin(), active_npc.end(), back_inserter( npcs_to_bring ),
10749 [this]( const shared_ptr_fast<npc> &np ) {
10750 return np->is_walking_with() && !np->is_mounted() && !np->in_sleep_state() &&
10751 rl_dist( np->pos(), u.pos() ) < 2;
10752 } );
10753 }
10754
10755 if( m.has_zlevels() && std::abs( movez ) == 1 ) {
10756 bool ladder = m.has_flag( "DIFFICULT_Z", u.pos() );
10757 for( monster &critter : all_monsters() ) {
10758 if( ladder && !critter.climbs() ) {
10759 continue;
10760 }
10761 if( critter.attack_target() == &g->u || ( !critter.has_effect( effect_ridden ) &&
10762 critter.has_effect( effect_pet ) && critter.friendly == -1 &&
10763 !critter.has_effect( effect_tied ) ) ) {
10764 monsters_following.push_back( &critter );
10765 }
10766 }
10767 }
10768
10769 if( u.is_mounted() ) {
10770 monster *crit = u.mounted_creature.get();
10771 if( crit->has_flag( MF_RIDEABLE_MECH ) ) {
10772 crit->use_mech_power( -1 );
10773 if( u.movement_mode_is( CMM_WALK ) ) {
10774 crit->use_mech_power( -2 );
10775 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
10776 crit->use_mech_power( -1 );
10777 } else if( u.movement_mode_is( CMM_RUN ) ) {
10778 crit->use_mech_power( -3 );
10779 }
10780 }
10781 } else {
10782 u.moves -= move_cost;
10783 }
10784 for( const auto &np : npcs_to_bring ) {
10785 if( np->in_vehicle ) {
10786 m.unboard_vehicle( np->pos() );
10787 }
10788 }
10789 const tripoint old_pos = g->u.pos();
10790 point submap_shift;
10791 vertical_shift( z_after );
10792 if( !force ) {
10793 submap_shift = update_map( stairs.x, stairs.y );
10794 }
10795
10796 // if an NPC or monster is on the stiars when player ascends/descends
10797 // they may end up merged on th esame tile, do some displacement to resolve that.
10798 // if, in the weird case of it not being possible to displace;
10799 // ( how did the player even manage to approach the stairs, if so? )
10800 // then nothing terrible happens, its just weird.
10801 if( critter_at<npc>( u.pos(), true ) || critter_at<monster>( u.pos(), true ) ) {
10802 std::string crit_name;
10803 bool player_displace = false;
10805 if( displace.has_value() ) {
10806 npc *guy = g->critter_at<npc>( u.pos(), true );
10807 if( guy ) {
10808 crit_name = guy->get_name();
10809 tripoint old_pos = guy->pos();
10810 if( !guy->is_enemy() ) {
10811 guy->move_away_from( u.pos(), true );
10812 if( old_pos != guy->pos() ) {
10813 add_msg( _( "%s moves out of the way for you." ), guy->get_name() );
10814 }
10815 } else {
10816 player_displace = true;
10817 }
10818 }
10819 monster *mon = g->critter_at<monster>( u.pos(), true );
10820 // if the monster is ridden by the player or an NPC:
10821 // Dont displace them. If they are mounted by a friendly NPC,
10822 // then the NPC will already have been displaced just above.
10823 // if they are ridden by the player, we want them to coexist on same tile
10824 if( mon && !mon->mounted_player ) {
10825 crit_name = mon->get_name();
10826 if( mon->friendly == -1 ) {
10827 mon->setpos( *displace );
10828 add_msg( _( "Your %s moves out of the way for you." ), mon->get_name() );
10829 } else {
10830 player_displace = true;
10831 }
10832 }
10833 if( player_displace ) {
10834 u.setpos( *displace );
10835 u.moves -= 20;
10836 add_msg( _( "You push past %s blocking the way." ), crit_name );
10837 }
10838 } else {
10839 debugmsg( "Failed to find a spot to displace into." );
10840 }
10841 }
10842
10843 // Now that we know the player's destination position, we can move their mount as well
10844 if( u.is_mounted() ) {
10845 if( stored_mount ) {
10846 assert( !m.has_zlevels() );
10847 stored_mount->spawn( g->u.pos() );
10848 if( critter_tracker->add( stored_mount ) ) {
10849 u.mounted_creature = stored_mount;
10850 }
10851 } else {
10852 u.mounted_creature->setpos( g->u.pos() );
10853 }
10854 }
10855
10856 if( !npcs_to_bring.empty() ) {
10857 // Would look nicer randomly scrambled
10858 std::vector<tripoint> candidates = closest_points_first( u.pos(), 1 );
10859 candidates.erase( std::remove_if( candidates.begin(), candidates.end(),
10860 [this]( const tripoint & c ) {
10861 return !is_empty( c );
10862 } ), candidates.end() );
10863
10864 for( const auto &np : npcs_to_bring ) {
10865 const auto found = std::find_if( candidates.begin(), candidates.end(),
10866 [this, np]( const tripoint & c ) {
10867 return !np->is_dangerous_fields( m.field_at( c ) ) && m.tr_at( c ).is_benign();
10868 } );
10869 if( found != candidates.end() ) {
10870 // TODO: De-uglify
10871 np->setpos( *found );
10872 np->place_on_map();
10873 np->setpos( *found );
10874 candidates.erase( found );
10875 }
10876
10877 if( candidates.empty() ) {
10878 break;
10879 }
10880 }
10881
10882 reload_npcs();
10883 }
10884
10885 // This ugly check is here because of stair teleport bullshit
10886 // TODO: Remove stair teleport bullshit
10887 if( rl_dist( g->u.pos(), old_pos ) <= 1 ) {
10888 for( monster *m : monsters_following ) {
10889 m->set_dest( g->u.pos() );
10890 }
10891 }
10892
10893 if( rope_ladder ) {
10894 m.ter_set( u.pos(), t_rope_up );
10895 }
10896
10897 if( m.ter( stairs ) == t_manhole_cover ) {
10898 m.spawn_item( stairs + point( rng( -1, 1 ), rng( -1, 1 ) ), itype_manhole_cover );
10899 m.ter_set( stairs, t_manhole );
10900 }
10901
10902 // Wouldn't work and may do strange things
10903 if( u.is_hauling() && !m.has_zlevels() ) {
10904 add_msg( _( "You cannot haul items here." ) );
10905 u.stop_hauling();
10906 }
10907
10908 if( u.is_hauling() ) {
10909 const tripoint adjusted_pos = old_pos - sm_to_ms_copy( submap_shift );
10910 start_hauling( adjusted_pos );
10911 }
10912
10913 m.invalidate_map_cache( g->get_levz() );
10914 // Upon force movement, traps can not be avoided.
10915 m.creature_on_trap( u, !force );
10916
10918}
static int move_cost(const item &it, const tripoint &src, const tripoint &dest)
@ CMM_WALK
Definition: character.h:101
@ CMM_CROUCH
Definition: character.h:103
bool move_effects(bool attacking) override
Processes effects which may prevent the Character from moving (bear traps, crushed,...
Definition: character.cpp:1538
int swim_speed() const
Returns the player's speed for swimming across water tiles.
Definition: character.cpp:882
int oxygen
Definition: character.h:1538
void mutation_spend_resources(const trait_id &mut)
Removes the appropriate costs (NOTE: will reapply mods & recalc sightlines in case of newly activated...
Definition: mutation.cpp:1723
int shoe_type_count(const itype_id &it) const
Returns 1 if the player is wearing an item of that count on one foot, 2 if on both,...
Definition: character.cpp:8961
std::string get_name() const override
Definition: character.cpp:6110
void start_hauling(const tripoint &pos)
Definition: game.cpp:10920
cata::optional< tripoint > find_or_make_stairs(map &mp, int z_after, bool &rope_ladder, bool peeking)
Returns the other end of the stairs (if any).
Definition: game.cpp:10955
bool use_mech_power(int amt)
Definition: monster.cpp:2368
Character * mounted_player
Definition: monster.h:458
void set_underwater(bool)
Definition: player.cpp:517
static const efftype_id effect_tied("tied")
static const itype_id itype_manhole_cover("manhole_cover")
static const skill_id skill_melee("melee")
static cata::optional< tripoint > point_selection_menu(const std::vector< tripoint > &pts)
Definition: game.cpp:10459
static const itype_id itype_swim_fins("swim_fins")
static const trait_id trait_WEB_ROPE("WEB_ROPE")
ter_id t_rope_up
Definition: mapdata.cpp:719
ter_id t_manhole
Definition: mapdata.cpp:718
bool can_use_mutation_warn(const trait_id &mut, const Character &character)
Calls can_use_mutation and if it fails, print a standard message.
Definition: mutation.cpp:1712
void avatar_moves(const avatar &u, const map &m, const tripoint &p)
Definition: game.cpp:12578
int ladder(player *, item *, bool, const tripoint &)
Definition: iuse.cpp:9344
int climbing_cost(const map &m, const tripoint &from, const tripoint &to)
Checks both the neighborhoods of from and to for climbable surfaces, returns move cost of climbing fr...
point displace(type dir, int dist=1)
Returns point(0, 0) displaced in specified direction by a specified distance.
Definition: overmap.cpp:4169

References _, active_npc, add_msg(), all_monsters(), cata_event_dispatch::avatar_moves(), c, can_use_mutation_warn(), map_funcs::climbing_cost(), closest_points_first(), CMM_CROUCH, CMM_RUN, CMM_WALK, coming_to_stairs, map::creature_on_trap(), critter_tracker, debugmsg, Character::dex_cur, dice(), om_direction::displace(), effect_pet, effect_ridden, effect_tied, find_empty_spot_nearby(), find_or_make_stairs(), monster::friendly, g, get_levx(), get_levy(), get_levz(), Character::get_name(), monster::get_name(), Character::get_skill_level(), avatar::grab(), player::grab_point, map::has_flag(), monster::has_flag(), map::has_floor_or_support(), Character::has_trait(), map::has_zlevels(), map::invalidate_map_cache(), npc::is_enemy(), Character::is_hauling(), Character::is_mounted(), Creature::is_underwater(), itype_manhole_cover, itype_swim_fins, iuse::ladder(), map::load(), m, m_bad, m_good, m_info, m_warning, MF_RIDEABLE_MECH, Creature::mod_moves(), monstairz, Character::mounted_creature, monster::mounted_player, npc::move_away_from(), move_cost(), Character::move_effects(), Character::movement_mode_is(), Creature::moves, Character::mutation_spend_resources(), om_direction::name(), OBJECT_NONE, OVERMAP_HEIGHT, Character::oxygen, map::passable(), point_selection_menu(), map::points_in_radius(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), query_yn(), reload_npcs(), remove_zombie(), rl_dist(), rng(), player::set_underwater(), Character::setpos(), monster::setpos(), shift_monsters(), Character::shoe_type_count(), skill_dodge, skill_melee, sm_to_ms_copy(), map::spawn_item(), start_hauling(), Character::stop_hauling(), Character::str_cur, Character::swim_speed(), t_manhole, t_manhole_cover, t_rope_up, map::ter(), map::ter_set(), map::tername(), TFLAG_DEEP_WATER, trait_WEB_ROPE, tripoint_zero, u, map::unboard_vehicle(), update_map(), update_stair_monsters(), monster::use_mech_power(), vertical_move(), vertical_shift(), Character::worn_with_flag(), tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by handle_action(), peek(), and vertical_move().

◆ vertical_notes()

void game::vertical_notes ( int  z_before,
int  z_after 
)

Add goes up/down auto_notes (if turned on)

Definition at line 11142 of file game.cpp.

11143{
11144 if( z_before == z_after || !get_option<bool>( "AUTO_NOTES" ) ||
11145 !get_option<bool>( "AUTO_NOTES_STAIRS" ) ) {
11146 return;
11147 }
11148
11149 if( !m.inbounds_z( z_before ) || !m.inbounds_z( z_after ) ) {
11150 debugmsg( "game::vertical_notes invalid arguments: z_before == %d, z_after == %d",
11151 z_before, z_after );
11152 return;
11153 }
11154 // Figure out where we know there are up/down connectors
11155 // Fill in all the tiles we know about (e.g. subway stations)
11156 static const int REVEAL_RADIUS = 40;
11157 for( const tripoint_abs_omt &p : points_in_radius( u.global_omt_location(), REVEAL_RADIUS ) ) {
11158 const tripoint_abs_omt cursp_before( p.xy(), z_before );
11159 const tripoint_abs_omt cursp_after( p.xy(), z_after );
11160
11161 if( !overmap_buffer.seen( cursp_before ) ) {
11162 continue;
11163 }
11164 if( overmap_buffer.has_note( cursp_after ) ) {
11165 // Already has a note -> never add an AUTO-note
11166 continue;
11167 }
11168 const oter_id &ter = overmap_buffer.ter( cursp_before );
11169 const oter_id &ter2 = overmap_buffer.ter( cursp_after );
11170 if( z_after > z_before && ter->has_flag( known_up ) &&
11171 !ter2->has_flag( known_down ) ) {
11172 overmap_buffer.set_seen( cursp_after, true );
11173 overmap_buffer.add_note( cursp_after, string_format( ">:W;%s", _( "AUTO: goes down" ) ) );
11174 } else if( z_after < z_before && ter->has_flag( known_down ) &&
11175 !ter2->has_flag( known_up ) ) {
11176 overmap_buffer.set_seen( cursp_after, true );
11177 overmap_buffer.add_note( cursp_after, string_format( "<:W;%s", _( "AUTO: goes up" ) ) );
11178 }
11179 }
11180}
bool inbounds_z(const int z) const
Definition: map.h:1643
void add_note(const tripoint_abs_omt &, const std::string &message)
@ known_up
Definition: omdata.h:87
@ known_down
Definition: omdata.h:86
bool has_flag(oter_flags flag) const
Definition: omdata.h:258

References _, overmapbuffer::add_note(), debugmsg, Character::global_omt_location(), oter_t::has_flag(), overmapbuffer::has_note(), map::inbounds_z(), known_down, known_up, m, overmap_buffer, points_in_radius(), overmapbuffer::seen(), overmapbuffer::set_seen(), string_format(), overmapbuffer::ter(), and u.

Referenced by vertical_shift().

◆ vertical_shift()

void game::vertical_shift ( int  z_after)

Actual z-level movement part of vertical_move.

Doesn't include stair finding, traps etc.

Definition at line 11105 of file game.cpp.

11106{
11107 if( z_after < -OVERMAP_DEPTH || z_after > OVERMAP_HEIGHT ) {
11108 debugmsg( "Tried to get z-level %d outside allowed range of %d-%d",
11109 z_after, -OVERMAP_DEPTH, OVERMAP_HEIGHT );
11110 return;
11111 }
11112
11113 // TODO: Implement dragging stuff up/down
11114 u.grab( OBJECT_NONE );
11115
11116 scent.reset();
11117
11118 u.setz( z_after );
11119 const int z_before = get_levz();
11120 if( !m.has_zlevels() ) {
11122 m.access_cache( z_before ).vehicle_list.clear();
11123 m.access_cache( z_before ).zone_vehicles.clear();
11124 m.access_cache( z_before ).map_memory_seen_cache.reset();
11125 m.set_transparency_cache_dirty( z_before );
11126 m.set_outside_cache_dirty( z_before );
11127 m.load( tripoint( get_levx(), get_levy(), z_after ), true );
11128 shift_monsters( tripoint( 0, 0, z_after - z_before ) );
11129 reload_npcs();
11130 } else {
11131 // Shift the map itself
11132 m.vertical_shift( z_after );
11133 }
11134
11135 m.spawn_monsters( true );
11136 // this may be required after a vertical shift if z-levels are not enabled
11137 // the critter is unloaded/loaded, and it needs to reconstruct its rider data after being reloaded.
11139 vertical_notes( z_before, z_after );
11140}
void setz(int z)
Definition: character.h:796
void vertical_notes(int z_before, int z_after)
Add goes up/down auto_notes (if turned on)
Definition: game.cpp:11142
void set_transparency_cache_dirty(const int zlev)
Sets a dirty flag on the a given cache.
Definition: map.h:393
void set_outside_cache_dirty(const int zlev)
Definition: map.h:430
void vertical_shift(int newz)
Moves the map vertically to (not by!) newz.
Definition: map.cpp:6767
std::set< vehicle * > zone_vehicles
Definition: map.h:346
std::set< vehicle * > vehicle_list
Definition: map.h:345

References map::access_cache(), map::clear_vehicle_cache(), debugmsg, get_levx(), get_levy(), get_levz(), avatar::grab(), map::has_zlevels(), map::load(), m, level_cache::map_memory_seen_cache, OBJECT_NONE, OVERMAP_DEPTH, OVERMAP_HEIGHT, reload_npcs(), scent_map::reset(), scent, map::set_outside_cache_dirty(), map::set_transparency_cache_dirty(), Character::setz(), shift_monsters(), map::spawn_monsters(), u, validate_mounted_npcs(), level_cache::vehicle_list, vertical_notes(), map::vertical_shift(), and level_cache::zone_vehicles.

Referenced by place_player(), and vertical_move().

◆ walk_move()

bool game::walk_move ( const tripoint dest,
bool  via_ramp = false 
)

TODO: This should really use the mounted creatures stamina, if mounted. Monsters don't currently have stamina however. For the time being just don't burn players stamina when mounted.

Dexterity decreases chance of tentacles getting stuck to the ground Intelligence decreases chance of tentacles getting stuck to the ground

Definition at line 9322 of file game.cpp.

9323{
9324 if( m.has_flag_ter( TFLAG_SMALL_PASSAGE, dest_loc ) ) {
9325 if( u.get_size() > MS_MEDIUM ) {
9326 add_msg( m_warning, _( "You can't fit there." ) );
9327 return false; // character too large to fit through a tight passage
9328 }
9329 if( u.is_mounted() ) {
9330 monster *mount = u.mounted_creature.get();
9331 if( mount->get_size() > MS_MEDIUM ) {
9332 add_msg( m_warning, _( "Your mount can't fit there." ) );
9333 return false; // char's mount is too large for tight passages
9334 }
9335 }
9336 }
9337
9338 if( u.is_mounted() ) {
9339 auto mons = u.mounted_creature.get();
9340 if( mons->has_flag( MF_RIDEABLE_MECH ) ) {
9341 if( !mons->check_mech_powered() ) {
9342 add_msg( m_bad, _( "Your %s refuses to move as its batteries have been drained." ),
9343 mons->get_name() );
9344 return false;
9345 }
9346 }
9347 if( !mons->move_effects( false ) ) {
9348 add_msg( m_bad, _( "You cannot move as your %s isn't able to move." ), mons->get_name() );
9349 return false;
9350 }
9351 }
9352 const optional_vpart_position vp_here = m.veh_at( u.pos() );
9353 const optional_vpart_position vp_there = m.veh_at( dest_loc );
9354
9355 bool pushing = false; // moving -into- grabbed tile; skip check for move_cost > 0
9356 bool pulling = false; // moving -away- from grabbed tile; check for move_cost > 0
9357 bool shifting_furniture = false; // moving furniture and staying still; skip check for move_cost > 0
9358
9359 const tripoint furn_pos = u.pos() + u.grab_point;
9360 const tripoint furn_dest = dest_loc + u.grab_point;
9361
9362 bool grabbed = u.get_grab_type() != OBJECT_NONE;
9363 if( grabbed ) {
9364 const tripoint dp = dest_loc - u.pos();
9365 pushing = dp == u.grab_point;
9366 pulling = dp == -u.grab_point;
9367 }
9368 if( grabbed && dest_loc.z != u.posz() ) {
9369 add_msg( m_warning, _( "You let go of the grabbed object." ) );
9370 grabbed = false;
9371 u.grab( OBJECT_NONE );
9372 }
9373
9374 // Now make sure we're actually holding something
9375 const vehicle *grabbed_vehicle = nullptr;
9376 if( grabbed && u.get_grab_type() == OBJECT_FURNITURE ) {
9377 // We only care about shifting, because it's the only one that can change our destination
9378 if( m.has_furn( u.pos() + u.grab_point ) ) {
9379 shifting_furniture = !pushing && !pulling;
9380 } else {
9381 // We were grabbing a furniture that isn't there
9382 grabbed = false;
9383 }
9384 } else if( grabbed && u.get_grab_type() == OBJECT_VEHICLE ) {
9385 grabbed_vehicle = veh_pointer_or_null( m.veh_at( u.pos() + u.grab_point ) );
9386 if( grabbed_vehicle == nullptr ) {
9387 // We were grabbing a vehicle that isn't there anymore
9388 grabbed = false;
9389 }
9390 } else if( grabbed ) {
9391 // We were grabbing something WEIRD, let's pretend we weren't
9392 grabbed = false;
9393 }
9394 if( u.grab_point != tripoint_zero && !grabbed ) {
9395 add_msg( m_warning, _( "Can't find grabbed object." ) );
9396 u.grab( OBJECT_NONE );
9397 }
9398
9399 if( m.impassable( dest_loc ) && !pushing && !shifting_furniture ) {
9400 if( vp_there && u.mounted_creature && u.mounted_creature->has_flag( MF_RIDEABLE_MECH ) &&
9401 vp_there->vehicle().handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
9402 tripoint diff = dest_loc - u.pos();
9403 if( diff.x < 0 ) {
9404 diff.x -= 2;
9405 } else if( diff.x > 0 ) {
9406 diff.x += 2;
9407 }
9408 if( diff.y < 0 ) {
9409 diff.y -= 2;
9410 } else if( diff.y > 0 ) {
9411 diff.y += 2;
9412 }
9413 u.mounted_creature->shove_vehicle( dest_loc + diff.xy(),
9414 dest_loc );
9415 }
9416 return false;
9417 }
9418 if( vp_there && !vp_there->vehicle().handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
9419 return false;
9420 }
9421 if( u.is_mounted() && !pushing && vp_there ) {
9422 add_msg( m_warning, _( "You cannot board a vehicle whilst riding." ) );
9423 return false;
9424 }
9425 u.set_underwater( false );
9426
9427 if( !shifting_furniture && !pushing && is_dangerous_tile( dest_loc ) ) {
9428 std::vector<std::string> harmful_stuff = get_dangerous_tile( dest_loc );
9429 if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "ALWAYS" &&
9430 !prompt_dangerous_tile( dest_loc ) ) {
9431 return true;
9432 } else if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "RUNNING" &&
9433 ( !u.movement_mode_is( CMM_RUN ) || !prompt_dangerous_tile( dest_loc ) ) ) {
9435 _( "Stepping into that %1$s looks risky. Run into it if you wish to enter anyway." ),
9436 enumerate_as_string( harmful_stuff ) );
9437 return true;
9438 } else if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "CROUCHING" &&
9439 ( !u.movement_mode_is( CMM_CROUCH ) || !prompt_dangerous_tile( dest_loc ) ) ) {
9441 _( "Stepping into that %1$s looks risky. Crouch and move into it if you wish to enter anyway." ),
9442 enumerate_as_string( harmful_stuff ) );
9443 return true;
9444 } else if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "NEVER" &&
9445 !u.movement_mode_is( CMM_RUN ) ) {
9447 _( "Stepping into that %1$s looks risky. Run into it if you wish to enter anyway." ),
9448 enumerate_as_string( harmful_stuff ) );
9449 return true;
9450 }
9451 }
9452 // Used to decide whether to print a 'moving is slow message
9453 const int mcost_from = m.move_cost( u.pos() ); //calculate this _before_ calling grabbed_move
9454
9455 int modifier = 0;
9456 if( grabbed && u.get_grab_type() == OBJECT_FURNITURE && u.pos() + u.grab_point == dest_loc ) {
9457 modifier = -m.furn( dest_loc ).obj().movecost;
9458 }
9459
9460 int multiplier = 1;
9461 if( u.is_on_ground() ) {
9462 multiplier *= 3;
9463 }
9464
9465 const int mcost = m.combined_movecost( u.pos(), dest_loc, grabbed_vehicle, modifier,
9466 via_ramp ) * multiplier;
9467 if( grabbed_move( dest_loc - u.pos() ) ) {
9468 return true;
9469 } else if( mcost == 0 ) {
9470 return false;
9471 }
9472 bool diag = trigdist && u.posx() != dest_loc.x && u.posy() != dest_loc.y;
9473 const int previous_moves = u.moves;
9474 if( u.is_mounted() ) {
9475 auto crit = u.mounted_creature.get();
9476 if( !crit->has_flag( MF_RIDEABLE_MECH ) &&
9477 ( m.has_flag_ter_or_furn( "MOUNTABLE", dest_loc ) ||
9478 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR", dest_loc ) ||
9479 m.has_flag_ter_or_furn( "OPENCLOSE_INSIDE", dest_loc ) ||
9480 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR_DAMAGED", dest_loc ) ||
9481 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR_REINFORCED", dest_loc ) ) ) {
9482 add_msg( m_warning, _( "You cannot pass obstacles whilst mounted." ) );
9483 return false;
9484 }
9485 const double base_moves = u.run_cost( mcost, diag ) * 100.0 / crit->get_speed();
9486 const double encumb_moves = u.get_weight() / 4800.0_gram;
9487 u.moves -= static_cast<int>( std::ceil( base_moves + encumb_moves ) );
9488 if( u.movement_mode_is( CMM_WALK ) ) {
9489 crit->use_mech_power( -2 );
9490 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
9491 crit->use_mech_power( -1 );
9492 } else if( u.movement_mode_is( CMM_RUN ) ) {
9493 crit->use_mech_power( -3 );
9494 }
9495 } else {
9496 u.moves -= u.run_cost( mcost, diag );
9497 /**
9498 TODO:
9499 This should really use the mounted creatures stamina, if mounted.
9500 Monsters don't currently have stamina however.
9501 For the time being just don't burn players stamina when mounted.
9502 */
9503 if( grabbed_vehicle == nullptr || grabbed_vehicle->wheelcache.empty() ) {
9504 //Burn normal amount of stamina if no vehicle grabbed or vehicle lacks wheels
9505 u.burn_move_stamina( previous_moves - u.moves );
9506 } else {
9507 //Burn half as much stamina if vehicle has wheels, without changing move time
9508 u.burn_move_stamina( 0.50 * ( previous_moves - u.moves ) );
9509 }
9510 }
9511 // Max out recoil & reset aim point
9514
9515 // Print a message if movement is slow
9516 const int mcost_to = m.move_cost( dest_loc ); //calculate this _after_ calling grabbed_move
9517 const bool fungus = m.has_flag_ter_or_furn( "FUNGUS", u.pos() ) ||
9518 m.has_flag_ter_or_furn( "FUNGUS",
9519 dest_loc ); //fungal furniture has no slowing effect on mycus characters
9520 const bool slowed = ( ( !u.has_trait( trait_PARKOUR ) && ( mcost_to > 2 || mcost_from > 2 ) ) ||
9521 mcost_to > 4 || mcost_from > 4 ) &&
9522 !( u.has_trait( trait_M_IMMUNE ) && fungus );
9523 if( slowed && !u.is_mounted() ) {
9524 // Unless u.pos() has a higher movecost than dest_loc, state that dest_loc is the cause
9525 if( mcost_to >= mcost_from ) {
9526 if( auto displayed_part = vp_there.part_displayed() ) {
9527 add_msg( m_warning, _( "Moving onto this %s is slow!" ),
9528 displayed_part->part().name() );
9529 sfx::do_obstacle( displayed_part->part().info().get_id().str() );
9530 } else {
9531 add_msg( m_warning, _( "Moving onto this %s is slow!" ), m.name( dest_loc ) );
9532 sfx::do_obstacle( m.ter( dest_loc ).id().str() );
9533 }
9534 } else {
9535 if( auto displayed_part = vp_here.part_displayed() ) {
9536 add_msg( m_warning, _( "Moving off of this %s is slow!" ),
9537 displayed_part->part().name() );
9538 sfx::do_obstacle( displayed_part->part().info().get_id().str() );
9539 } else {
9540 add_msg( m_warning, _( "Moving off of this %s is slow!" ), m.name( u.pos() ) );
9541 sfx::do_obstacle( m.ter( u.pos() ).id().str() );
9542 }
9543 }
9544 }
9545 if( !u.is_mounted() && u.has_trait( trait_id( "LEG_TENT_BRACE" ) ) &&
9546 ( !u.footwear_factor() ||
9547 ( u.footwear_factor() == .5 && one_in( 2 ) ) ) ) {
9548 // DX and IN are long suits for Cephalopods,
9549 // so this shouldn't cause too much hardship
9550 // Presumed that if it's swimmable, they're
9551 // swimming and won't stick
9552 ///\EFFECT_DEX decreases chance of tentacles getting stuck to the ground
9553
9554 ///\EFFECT_INT decreases chance of tentacles getting stuck to the ground
9555 if( !m.has_flag( "SWIMMABLE", dest_loc ) && one_in( 80 + u.dex_cur + u.int_cur ) ) {
9556 add_msg( _( "Your tentacles stick to the ground, but you pull them free." ) );
9557 u.mod_fatigue( 1 );
9558 }
9559 }
9560 if( !u.has_artifact_with( AEP_STEALTH ) && !u.has_trait( trait_id( "DEBUG_SILENT" ) ) ) {
9561 int volume = u.is_stealthy() ? 3 : 6;
9562 volume *= u.mutation_value( "noise_modifier" );
9563 if( volume > 0 ) {
9565 volume = 2;
9566 } else if( u.has_bionic( bionic_id( "bio_ankles" ) ) ) {
9567 volume = 12;
9568 }
9569 if( u.movement_mode_is( CMM_RUN ) ) {
9570 volume *= 1.5;
9571 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
9572 volume /= 2;
9573 }
9574 if( u.is_mounted() ) {
9575 auto mons = u.mounted_creature.get();
9576 switch( mons->get_size() ) {
9577 case MS_TINY:
9578 volume = 0; // No sound for the tinies
9579 break;
9580 case MS_SMALL:
9581 volume /= 3;
9582 break;
9583 case MS_MEDIUM:
9584 break;
9585 case MS_LARGE:
9586 volume *= 1.5;
9587 break;
9588 case MS_HUGE:
9589 volume *= 2;
9590 break;
9591 default:
9592 break;
9593 }
9594 if( mons->has_flag( MF_LOUDMOVES ) ) {
9595 volume += 6;
9596 }
9597 sounds::sound( dest_loc, volume, sounds::sound_t::movement, mons->type->get_footsteps(), false,
9598 "none", "none" );
9599 } else {
9600 sounds::sound( dest_loc, volume, sounds::sound_t::movement, _( "footsteps" ), true,
9601 "none", "none" ); // Sound of footsteps may awaken nearby monsters
9602 }
9604 }
9605
9606 if( one_in( 20 ) && u.has_artifact_with( AEP_MOVEMENT_NOISE ) ) {
9607 sounds::sound( u.pos(), 40, sounds::sound_t::movement, _( "a rattling sound." ), true,
9608 "misc", "rattling" );
9609 }
9610 }
9611
9612 if( m.has_flag_ter_or_furn( TFLAG_HIDE_PLACE, dest_loc ) ) {
9613 add_msg( m_good, _( "You are hiding in the %s." ), m.name( dest_loc ) );
9614 }
9615
9616 if( dest_loc != u.pos() ) {
9618 }
9619
9620 tripoint oldpos = u.pos();
9621 point submap_shift = place_player( dest_loc );
9622 point ms_shift = sm_to_ms_copy( submap_shift );
9623 oldpos = oldpos - ms_shift;
9624
9625 if( pulling ) {
9626 const tripoint shifted_furn_pos = furn_pos - ms_shift;
9627 const tripoint shifted_furn_dest = furn_dest - ms_shift;
9628 const time_duration fire_age = m.get_field_age( shifted_furn_pos, fd_fire );
9629 const int fire_intensity = m.get_field_intensity( shifted_furn_pos, fd_fire );
9630 m.remove_field( shifted_furn_pos, fd_fire );
9631 m.set_field_intensity( shifted_furn_dest, fd_fire, fire_intensity );
9632 m.set_field_age( shifted_furn_dest, fd_fire, fire_age );
9633 }
9634
9635 if( u.is_hauling() ) {
9636 start_hauling( oldpos );
9637 }
9638
9640
9641 return true;
9642}
void burn_move_stamina(int moves)
Definition: character.cpp:7237
virtual bool has_artifact_with(art_effect_passive effect) const
Definition: character.cpp:3223
units::mass get_weight() const override
Returns body weight plus weight of inventory and worn/wielded items.
Definition: character.cpp:3667
bool is_on_ground() const override
Returns true if the player is knocked over or has broken legs.
Definition: character.cpp:962
float mutation_value(const std::string &val) const
Goes over all mutations, gets min and max of a value with given name.
Definition: character.cpp:6765
int run_cost(int base_cost, bool diag=false) const
Returns the player's modified base movement cost.
m_size get_size() const override
Get size class of character.
Definition: character.cpp:541
bool grabbed_move(const tripoint &dp)
Check for dangerous stuff at dest_loc, return false if the player decides not to step there.
Definition: game.cpp:10248
bool is_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:9251
const string_id< T > & id() const
Definition: ammo_effect.cpp:33
int combined_movecost(const tripoint &from, const tripoint &to, const vehicle *ignored_vehicle=nullptr, int modifier=0, bool flying=false, bool via_ramp=false) const
Cost to move out of one tile and into the next.
Definition: map.cpp:1833
m_size get_size() const override
Definition: monster.cpp:2668
cata::optional< vpart_reference > part_displayed() const
Definition: vehicle.cpp:2498
bool is_stealthy() const
Returns true if the player has stealthy movement.
cata::optional< tripoint > last_target_pos
Definition: player.h:648
@ MS_TINY
Definition: creature.h:58
@ MS_LARGE
Definition: creature.h:61
@ MS_MEDIUM
Definition: creature.h:60
static const itype_id itype_rm13_armor_on("rm13_armor_on")
static const trait_id trait_M_IMMUNE("M_IMMUNE")
@ TFLAG_SMALL_PASSAGE
Definition: mapdata.h:320
@ TFLAG_HIDE_PLACE
Definition: mapdata.h:315
@ MF_LOUDMOVES
Definition: mtype.h:175
void fungus(player &p, const tripoint &examp)
Remove furniture.
Definition: iexamine.cpp:2147
void do_obstacle(const std::string &obst="")
Definition: sounds.cpp:1635
void do_footstep()
Definition: sounds.cpp:1612

References _, add_msg(), AEP_MOVEMENT_NOISE, AEP_STEALTH, cata_event_dispatch::avatar_moves(), Character::burn_move_stamina(), CMM_CROUCH, CMM_RUN, CMM_WALK, map::combined_movecost(), Character::dex_cur, sfx::do_footstep(), sfx::do_obstacle(), enumerate_as_string(), fd_fire, Character::footwear_factor(), iexamine::fungus(), map::furn(), get_dangerous_tile(), map::get_field_age(), map::get_field_intensity(), avatar::get_grab_type(), Character::get_size(), monster::get_size(), Character::get_weight(), avatar::grab(), player::grab_point, grabbed_move(), Character::has_artifact_with(), Character::has_bionic(), map::has_flag(), map::has_flag_ter(), map::has_flag_ter_or_furn(), map::has_furn(), Character::has_trait(), int_id< T >::id(), map::impassable(), Character::int_cur, is_dangerous_tile(), Character::is_hauling(), Character::is_mounted(), Character::is_on_ground(), player::is_stealthy(), Character::is_wearing(), itype_rm13_armor_on, player::last_target_pos, m, m_bad, m_good, m_warning, MAX_RECOIL, MF_LOUDMOVES, MF_RIDEABLE_MECH, Character::mod_fatigue(), Character::mounted_creature, map::move_cost(), map_data_common_t::movecost, sounds::movement, Character::movement_mode_is(), Creature::moves, MS_HUGE, MS_LARGE, MS_MEDIUM, MS_SMALL, MS_TINY, Character::mutation_value(), map::name(), cata::nullopt, int_id< T >::obj(), OBJECT_FURNITURE, OBJECT_NONE, OBJECT_VEHICLE, on_move_effects(), one_in(), optional_vpart_position::part_displayed(), place_player(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), prompt_dangerous_tile(), Character::recoil, map::remove_field(), Character::run_cost(), map::set_field_age(), map::set_field_intensity(), player::set_underwater(), sm_to_ms_copy(), sounds::sound(), start_hauling(), string_id< T >::str(), map::ter(), TFLAG_HIDE_PLACE, TFLAG_SMALL_PASSAGE, trait_M_IMMUNE, trait_PARKOUR, trigdist, tripoint_zero, u, map::veh_at(), veh_pointer_or_null(), vehicle::wheelcache, tripoint::x, tripoint::xy(), tripoint::y, and tripoint::z.

Referenced by swap_critters().

◆ wield() [1/2]

void game::wield ( )
private

Definition at line 9111 of file game.cpp.

9112{
9114
9115 if( loc ) {
9116 wield( loc );
9117 } else {
9118 add_msg( _( "Never mind." ) );
9119 }
9120}
item_location wield(avatar &you)
Item wielding/unwielding menu.

References _, add_msg(), u, wield(), and game_menus::inv::wield().

Referenced by handle_action(), inventory_item_menu(), and wield().

◆ wield() [2/2]

void game::wield ( item_location loc)
private

Definition at line 9023 of file game.cpp.

9024{
9025 if( u.is_armed() ) {
9026 const bool is_unwielding = u.is_wielding( *loc );
9027 const auto ret = u.can_unwield( *loc );
9028
9029 if( !ret.success() ) {
9030 add_msg( m_info, "%s", ret.c_str() );
9031 }
9032
9033 u.unwield();
9034
9035 if( is_unwielding ) {
9036 if( !u.martial_arts_data->selected_is_none() ) {
9037 u.martial_arts_data->martialart_use_message( u );
9038 }
9039 return;
9040 }
9041 }
9042
9043 const auto ret = u.can_wield( *loc );
9044 if( !ret.success() ) {
9045 add_msg( m_info, "%s", ret.c_str() );
9046 }
9047
9048 // Need to do this here because holster_actor::use() checks if/where the item is worn
9049 item &target = *loc.get_item();
9050 if( target.get_use( "holster" ) && !target.contents.empty() ) {
9051 //~ %1$s: weapon name, %2$s: holster name
9052 if( query_yn( pgettext( "holster", "Draw %1$s from %2$s?" ), target.get_contained().tname(),
9053 target.tname() ) ) {
9054 u.invoke_item( &target );
9055 return;
9056 }
9057 }
9058
9059 // Can't use loc.obtain() here because that would cause things to spill.
9060 item to_wield = *loc.get_item();
9061 item_location::type location_type = loc.where();
9062 tripoint pos = loc.position();
9063 int worn_index = INT_MIN;
9064 if( u.is_worn( *loc.get_item() ) ) {
9065 auto ret = u.can_takeoff( *loc.get_item() );
9066 if( !ret.success() ) {
9067 add_msg( m_info, "%s", ret.c_str() );
9068 return;
9069 }
9070 int item_pos = u.get_item_position( loc.get_item() );
9071 if( item_pos != INT_MIN ) {
9072 worn_index = Character::worn_position_to_index( item_pos );
9073 }
9074 }
9075 loc.remove_item();
9076 if( !u.wield( to_wield ) ) {
9077 switch( location_type ) {
9079 // this will not cause things to spill, as it is inside another item
9080 loc = loc.obtain( g->u );
9081 wield( loc );
9082 break;
9084 if( worn_index != INT_MIN ) {
9085 auto it = u.worn.begin();
9086 std::advance( it, worn_index );
9087 u.worn.insert( it, to_wield );
9088 } else {
9089 u.i_add( to_wield );
9090 }
9091 break;
9093 m.add_item( pos, to_wield );
9094 break;
9096 const cata::optional<vpart_reference> vp = m.veh_at( pos ).part_with_feature( "CARGO", false );
9097 // If we fail to return the item to the vehicle for some reason, add it to the map instead.
9098 if( !vp || !( vp->vehicle().add_item( vp->part_index(), to_wield ) ) ) {
9099 m.add_item( pos, to_wield );
9100 }
9101 break;
9102 }
9104 debugmsg( "Failed wield from invalid item location" );
9105 break;
9106 }
9107 return;
9108 }
9109}
std::list< item > worn
Definition: character.h:1515
static int worn_position_to_index(int position)
Definition: character.h:1079
item & i_add(item it, bool should_stack=true)
Definition: character.cpp:2324
bool wield(item &target) override
Removes currently wielded item (if any) and replaces it with the target item.
Definition: avatar.cpp:1185
type where() const
Returns the type of location where the item is found.
void remove_item()
Removes the selected item from the game.
tripoint position() const
Returns the position where the item is found.
const item & get_contained() const
Return a contained item (if any and only one).
Definition: item.cpp:6884
item & add_item(const tripoint &p, item new_item)
Place an item on the map, despite the parameter name, this is not necessarily a new item.
Definition: map.cpp:4314
ret_val< bool > can_wield(const item &it) const
Check player capable of wielding an item.
Definition: player.cpp:2371
bool unwield()
Definition: player.cpp:2410

References map::add_item(), add_msg(), player::can_takeoff(), Character::can_unwield(), player::can_wield(), item_location::character, item_location::container, item::contents, debugmsg, item_contents::empty(), g, item::get_contained(), item_location::get_item(), Character::get_item_position(), item::get_use(), Character::i_add(), item_location::invalid, avatar::invoke_item(), Character::is_armed(), Character::is_wielding(), Character::is_worn(), m, m_info, item_location::map, Character::martial_arts_data, item_location::obtain(), optional_vpart_position::part_with_feature(), pgettext(), item_location::position(), query_yn(), item_location::remove_item(), cata::hash64_detail::ret, item::tname(), u, player::unwield(), map::veh_at(), item_location::vehicle, item_location::where(), wield(), avatar::wield(), Character::worn, and Character::worn_position_to_index().

◆ win()

void game::win ( )

Marks the game as won.

Doesn't end the game.

Definition at line 2748 of file game.cpp.

2749{
2750 win_screen();
2752 memorial().add(
2753 pgettext( "memorial_male", "Closed the portal in %1$.1f days (%2$d seconds)." ),
2754 pgettext( "memorial_female", "Closed the portal in %1$.1f days (%2$d seconds)." ),
2755 to_days<float>( game_duration ), to_seconds<int>( game_duration ) );
2756 if( !u.is_dead_state() ) {
2759 }
2760}
void win_screen()
Definition: game.cpp:2762
void add(const std::string &male_msg, const std::string &female_msg)
Adds an event to the memorial log, to be written to the memorial file when the character dies.
const time_point & start_of_game
Definition: calendar.cpp:34

References achievements_tracker_ptr, memorial_logger::add(), Messages::display_messages(), get_kill_tracker(), player::is_dead_state(), memorial(), pgettext(), show_scores_ui(), calendar::start_of_game, stats(), calendar::turn, u, and win_screen().

◆ win_screen()

void game::win_screen ( )
private

Definition at line 2762 of file game.cpp.

2763{
2764 // TODO: Move this wall somewhere
2766 std::string msg = _( "You managed to close the portal and end the invasion!" );
2767 msg += '\n';
2768 if( u.is_dead_state() ) {
2770 "Unfortunately, you had to sacrifice your life to achieve this." );
2771 msg += colorize( t, c_red ) + '\n';
2772 memorial().add(
2773 pgettext( "memorial_male", "Sacrificed his life to close the portal." ),
2774 pgettext( "memorial_female", "Sacrificed her life to close the portal." ) );
2775 } else {
2776 translation t = translation::to_translation( "win_game", "You managed to survive the ordeal." );
2777 msg += colorize( t, c_green ) + '\n';
2778 memorial().add(
2779 pgettext( "memorial_male", "Safely closed the portal." ),
2780 pgettext( "memorial_female", "Safely closed the portal." ) );
2781 }
2782 msg += string_format( _( "It took you %1$.1f days (%2$d seconds)." ),
2783 to_days<float>( game_duration ), to_seconds<int>( game_duration ) );
2784 // TODO: Print starting stats, traits, skills, all mods ever used, easiest of settings
2785 popup( msg );
2786}
Class for storing translation context and raw string for deferred translation.
Definition: translations.h:152
static translation to_translation(const std::string &raw)
Store a string, an optional plural form, and an optional context for translation.
std::string colorize(const std::string &text, const nc_color &color)
Definition: color.cpp:669

References _, memorial_logger::add(), c_green, c_red, colorize(), player::is_dead_state(), memorial(), pgettext(), popup(), calendar::start_of_game, string_format(), translation::to_translation(), calendar::turn, and u.

Referenced by win().

◆ write_memorial_file()

void game::write_memorial_file ( const std::string &  filename,
std::string  sLastWords 
)

Writes information about the character out to a text file timestamped with the time of the file was made.

This serves as a record of the character's state at the time the memorial was made (usually upon death) and accomplishments in a human-readable format.

Definition at line 3151 of file game.cpp.

3152{
3153 const std::string &memorial_dir = PATH_INFO::memorialdir();
3154 const std::string &memorial_active_world_dir = memorial_dir +
3155 world_generator->active_world->world_name + "/";
3156
3157 //Check if both dirs exist. Nested assure_dir_exist fails if the first dir of the nested dir does not exist.
3158 if( !assure_dir_exist( memorial_dir ) ) {
3159 debugmsg( "Could not make '%s' directory", memorial_dir );
3160 return;
3161 }
3162
3163 if( !assure_dir_exist( memorial_active_world_dir ) ) {
3164 debugmsg( "Could not make '%s' directory", memorial_active_world_dir );
3165 return;
3166 }
3167
3168 std::string path = memorial_active_world_dir + filename + ".txt";
3169
3170 write_to_file( path, [&]( std::ostream & fout ) {
3171 memorial().write( fout, sLastWords );
3172 }, _( "player memorial" ) );
3173}
void write(std::ostream &memorial_file, const std::string &epitaph) const
std::string memorialdir()
Definition: path_info.cpp:226

References _, assure_dir_exist(), debugmsg, memorial(), PATH_INFO::memorialdir(), world_generator, memorial_logger::write(), and write_to_file().

Referenced by cleanup_at_end().

◆ zones_manager()

void game::zones_manager ( )

Definition at line 6377 of file game.cpp.

6378{
6379 const tripoint stored_view_offset = u.view_offset;
6380
6382
6383 const int zone_ui_height = 12;
6384 const int zone_options_height = 7;
6385
6386 const int width = 45;
6387
6388 int offsetX = 0;
6389 int max_rows = 0;
6390
6391 catacurses::window w_zones;
6392 catacurses::window w_zones_border;
6393 catacurses::window w_zones_info;
6394 catacurses::window w_zones_info_border;
6395 catacurses::window w_zones_options;
6396
6397 bool show = true;
6398
6399 ui_adaptor ui;
6400 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
6401 if( !show ) {
6402 ui.position( point_zero, point_zero );
6403 return;
6404 }
6405 offsetX = get_option<std::string>( "SIDEBAR_POSITION" ) != "left" ?
6406 TERMX - width : 0;
6407 const int w_zone_height = TERMY - zone_ui_height;
6408 max_rows = w_zone_height - 2;
6409 w_zones = catacurses::newwin( w_zone_height - 2, width - 2,
6410 point( offsetX + 1, 1 ) );
6411 w_zones_border = catacurses::newwin( w_zone_height, width,
6412 point( offsetX, 0 ) );
6413 w_zones_info = catacurses::newwin( zone_ui_height - zone_options_height - 1,
6414 width - 2, point( offsetX + 1, w_zone_height ) );
6415 w_zones_info_border = catacurses::newwin( zone_ui_height, width,
6416 point( offsetX, w_zone_height ) );
6417 w_zones_options = catacurses::newwin( zone_options_height - 1, width - 2,
6418 point( offsetX + 1, TERMY - zone_options_height ) );
6419
6420 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
6421 } );
6422 ui.mark_resize();
6423
6424 std::string action;
6425 input_context ctxt( "ZONES_MANAGER" );
6426 ctxt.register_cardinal();
6427 ctxt.register_action( "CONFIRM" );
6428 ctxt.register_action( "QUIT" );
6429 ctxt.register_action( "ADD_ZONE" );
6430 ctxt.register_action( "REMOVE_ZONE" );
6431 ctxt.register_action( "MOVE_ZONE_UP" );
6432 ctxt.register_action( "MOVE_ZONE_DOWN" );
6433 ctxt.register_action( "SHOW_ZONE_ON_MAP" );
6434 ctxt.register_action( "ENABLE_ZONE" );
6435 ctxt.register_action( "DISABLE_ZONE" );
6436 ctxt.register_action( "SHOW_ALL_ZONES" );
6437 ctxt.register_action( "HELP_KEYBINDINGS" );
6438
6439 auto &mgr = zone_manager::get_manager();
6440 int start_index = 0;
6441 int active_index = 0;
6442 bool blink = false;
6443 bool stuff_changed = false;
6444 bool show_all_zones = false;
6445 int zone_cnt = 0;
6446
6447 // get zones on the same z-level, with distance between player and
6448 // zone center point <= 50 or all zones, if show_all_zones is true
6449 auto get_zones = [&]() {
6450 std::vector<zone_manager::ref_zone_data> zones;
6451 if( show_all_zones ) {
6452 zones = mgr.get_zones();
6453 } else {
6454 const tripoint &u_abs_pos = m.getabs( u.pos() );
6455 for( zone_manager::ref_zone_data &ref : mgr.get_zones() ) {
6456 const tripoint &zone_abs_pos = ref.get().get_center_point();
6457 if( u_abs_pos.z == zone_abs_pos.z && rl_dist( u_abs_pos, zone_abs_pos ) <= 50 ) {
6458 zones.emplace_back( ref );
6459 }
6460 }
6461 }
6462 zone_cnt = static_cast<int>( zones.size() );
6463 return zones;
6464 };
6465
6466 auto zones = get_zones();
6467
6468 auto zones_manager_options = [&]() {
6469 werase( w_zones_options );
6470
6471 if( zone_cnt > 0 ) {
6472 const auto &zone = zones[active_index].get();
6473
6474 if( zone.has_options() ) {
6475 const auto &descriptions = zone.get_options().get_descriptions();
6476
6477 // NOLINTNEXTLINE(cata-use-named-point-constants)
6478 mvwprintz( w_zones_options, point( 1, 0 ), c_white, _( "Options" ) );
6479
6480 int y = 1;
6481 for( const auto &desc : descriptions ) {
6482 mvwprintz( w_zones_options, point( 3, y ), c_white, desc.first );
6483 mvwprintz( w_zones_options, point( 20, y ), c_white, desc.second );
6484 y++;
6485 }
6486 }
6487 }
6488
6489 wnoutrefresh( w_zones_options );
6490 };
6491
6492 cata::optional<tripoint> zone_start;
6493 cata::optional<tripoint> zone_end;
6494 bool zone_blink = false;
6495 bool zone_cursor = false;
6497 zone_start, zone_end, zone_blink, zone_cursor );
6498 add_draw_callback( zone_cb );
6499
6500 auto query_position =
6501 [&]() -> cata::optional<std::pair<tripoint, tripoint>> {
6502 on_out_of_scope invalidate_current_ui( [&]()
6503 {
6504 ui.mark_resize();
6505 } );
6506 restore_on_out_of_scope<bool> show_prev( show );
6507 restore_on_out_of_scope<cata::optional<tripoint>> zone_start_prev( zone_start );
6508 restore_on_out_of_scope<cata::optional<tripoint>> zone_end_prev( zone_end );
6509 show = false;
6510 zone_start = cata::nullopt;
6511 zone_end = cata::nullopt;
6512 ui.mark_resize();
6513
6515 popup.on_top( true );
6516 popup.message( "%s", _( "Select first point." ) );
6517
6519
6520 const look_around_result first = look_around( /*show_window=*/false, center, center, false, true,
6521 false );
6522 if( first.position )
6523 {
6524 popup.message( "%s", _( "Select second point." ) );
6525
6526 const look_around_result second = look_around( /*show_window=*/false, center, *first.position,
6527 true, true, false );
6528 if( second.position ) {
6529 tripoint first_abs = m.getabs( tripoint( std::min( first.position->x,
6530 second.position->x ),
6531 std::min( first.position->y, second.position->y ),
6532 std::min( first.position->z,
6533 second.position->z ) ) );
6534 tripoint second_abs = m.getabs( tripoint( std::max( first.position->x,
6535 second.position->x ),
6536 std::max( first.position->y, second.position->y ),
6537 std::max( first.position->z,
6538 second.position->z ) ) );
6539 return std::pair<tripoint, tripoint>( first_abs, second_abs );
6540 }
6541 }
6542
6543 return cata::nullopt;
6544 };
6545
6546 ui.on_redraw( [&]( const ui_adaptor & ) {
6547 if( !show ) {
6548 return;
6549 }
6550 zones_manager_draw_borders( w_zones_border, w_zones_info_border, zone_ui_height, width );
6551 zones_manager_shortcuts( w_zones_info );
6552
6553 if( zone_cnt == 0 ) {
6554 werase( w_zones );
6555 mvwprintz( w_zones, point( 2, 5 ), c_white, _( "No Zones defined." ) );
6556
6557 } else {
6558 werase( w_zones );
6559
6560 calcStartPos( start_index, active_index, max_rows, zone_cnt );
6561
6562 draw_scrollbar( w_zones_border, active_index, max_rows, zone_cnt, point_south );
6563 wnoutrefresh( w_zones_border );
6564
6565 int iNum = 0;
6566
6567 tripoint player_absolute_pos = m.getabs( u.pos() );
6568
6569 //Display saved zones
6570 for( auto &i : zones ) {
6571 if( iNum >= start_index &&
6572 iNum < start_index + ( ( max_rows > zone_cnt ) ? zone_cnt : max_rows ) ) {
6573 const auto &zone = i.get();
6574
6575 nc_color colorLine = ( zone.get_enabled() ) ? c_white : c_light_gray;
6576
6577 if( iNum == active_index ) {
6578 mvwprintz( w_zones, point( 0, iNum - start_index ), c_yellow, "%s", ">>" );
6579 colorLine = ( zone.get_enabled() ) ? c_light_green : c_green;
6580 }
6581
6582 //Draw Zone name
6583 mvwprintz( w_zones, point( 3, iNum - start_index ), colorLine,
6584 trim_by_length( zone.get_name(), 15 ) );
6585
6586 //Draw Type name
6587 mvwprintz( w_zones, point( 20, iNum - start_index ), colorLine,
6588 mgr.get_name_from_type( zone.get_type() ) );
6589
6590 tripoint center = zone.get_center_point();
6591
6592 //Draw direction + distance
6593 mvwprintz( w_zones, point( 32, iNum - start_index ), colorLine, "%*d %s",
6594 5, static_cast<int>( trig_dist( player_absolute_pos, center ) ),
6595 direction_name_short( direction_from( player_absolute_pos,
6596 center ) ) );
6597
6598 //Draw Vehicle Indicator
6599 mvwprintz( w_zones, point( 41, iNum - start_index ), colorLine,
6600 zone.get_is_vehicle() ? "*" : "" );
6601 }
6602 iNum++;
6603 }
6604
6605 // Display zone options
6606 zones_manager_options();
6607 }
6608
6609 wnoutrefresh( w_zones );
6610 } );
6611
6612 zones_manager_open = true;
6613 do {
6614 if( action == "ADD_ZONE" ) {
6615 do { // not a loop, just for quick bailing out if canceled
6616 const auto maybe_id = mgr.query_type();
6617 if( !maybe_id.has_value() ) {
6618 break;
6619 }
6620
6621 const zone_type_id &id = maybe_id.value();
6622 auto options = zone_options::create( id );
6623
6624 if( !options->query_at_creation() ) {
6625 break;
6626 }
6627
6628 auto default_name = options->get_zone_name_suggestion();
6629 if( default_name.empty() ) {
6630 default_name = mgr.get_name_from_type( id );
6631 }
6632 const auto maybe_name = mgr.query_name( default_name );
6633 if( !maybe_name.has_value() ) {
6634 break;
6635 }
6636 const std::string &name = maybe_name.value();
6637
6638 const auto position = query_position();
6639 if( !position ) {
6640 break;
6641 }
6642
6643 mgr.add( name, id, g->u.get_faction()->id, false, true, position->first,
6644 position->second, options );
6645
6646 zones = get_zones();
6647 active_index = zone_cnt - 1;
6648
6649 stuff_changed = true;
6650 } while( false );
6651
6652 blink = false;
6653 } else if( action == "SHOW_ALL_ZONES" ) {
6654 show_all_zones = !show_all_zones;
6655 zones = get_zones();
6656 active_index = 0;
6657 } else if( zone_cnt > 0 ) {
6658 if( action == "UP" ) {
6659 active_index--;
6660 if( active_index < 0 ) {
6661 active_index = zone_cnt - 1;
6662 }
6663 blink = false;
6664 } else if( action == "DOWN" ) {
6665 active_index++;
6666 if( active_index >= zone_cnt ) {
6667 active_index = 0;
6668 }
6669 blink = false;
6670 } else if( action == "REMOVE_ZONE" ) {
6671 if( active_index < zone_cnt ) {
6672 mgr.remove( zones[active_index] );
6673 zones = get_zones();
6674 active_index--;
6675
6676 if( active_index < 0 ) {
6677 active_index = 0;
6678 }
6679 }
6680 blink = false;
6681 stuff_changed = true;
6682
6683 } else if( action == "CONFIRM" ) {
6684 auto &zone = zones[active_index].get();
6685
6686 uilist as_m;
6687 as_m.text = _( "What do you want to change:" );
6688 as_m.entries.emplace_back( 1, true, '1', _( "Edit name" ) );
6689 as_m.entries.emplace_back( 2, true, '2', _( "Edit type" ) );
6690 as_m.entries.emplace_back( 3, zone.get_options().has_options(), '3',
6691 zone.get_type() == zone_type_id( "LOOT_CUSTOM" ) ? _( "Edit filter" ) : _( "Edit options" ) );
6692 as_m.entries.emplace_back( 4, !zone.get_is_vehicle(), '4', _( "Edit position" ) );
6693 // TODO: Enable moving vzone after vehicle zone can be bigger than 1*1
6694 as_m.entries.emplace_back( 5, !zone.get_is_vehicle(), '5', _( "Move position" ) );
6695 as_m.query();
6696
6697 switch( as_m.ret ) {
6698 case 1:
6699 if( zone.set_name() ) {
6700 stuff_changed = true;
6701 }
6702 break;
6703 case 2:
6704 if( zone.set_type() ) {
6705 stuff_changed = true;
6706 }
6707 break;
6708 case 3:
6709 if( zone.get_options().query() ) {
6710 stuff_changed = true;
6711 }
6712 break;
6713 case 4: {
6714 const auto pos = query_position();
6715 if( pos && ( pos->first != zone.get_start_point() ||
6716 pos->second != zone.get_end_point() ) ) {
6717 zone.set_position( *pos );
6718 stuff_changed = true;
6719 }
6720 break;
6721 }
6722 case 5: {
6723 on_out_of_scope invalidate_current_ui( [&]() {
6724 ui.mark_resize();
6725 } );
6726 restore_on_out_of_scope<bool> show_prev( show );
6727 restore_on_out_of_scope<cata::optional<tripoint>> zone_start_prev( zone_start );
6728 restore_on_out_of_scope<cata::optional<tripoint>> zone_end_prev( zone_end );
6729 show = false;
6730 zone_start = cata::nullopt;
6731 zone_end = cata::nullopt;
6732 ui.mark_resize();
6733 static_popup message_pop;
6734 message_pop.on_top( true );
6735 message_pop.message( "%s", _( "Moving zone." ) );
6736 const auto zone_local_start_point = m.getlocal( zone.get_start_point() );
6737 const auto zone_local_end_point = m.getlocal( zone.get_end_point() );
6738 // local position of the zone center, used to calculate the u.view_offset,
6739 // could center the screen to the position it represents
6740 auto view_center = m.getlocal( zone.get_center_point() );
6741 const look_around_result result_local = look_around( false, view_center,
6742 zone_local_start_point, false, false,
6743 false, true, zone_local_end_point );
6744 if( result_local.position ) {
6745 const auto new_start_point = m.getabs( *result_local.position );
6746 if( new_start_point == zone.get_start_point() ) {
6747 break; // Nothing changed, don't save
6748 }
6749
6750 const auto new_end_point = zone.get_end_point() - zone.get_start_point() + new_start_point;
6751 zone.set_position( std::pair<tripoint, tripoint>( new_start_point, new_end_point ) );
6752 stuff_changed = true;
6753 }
6754 }
6755 break;
6756 default:
6757 break;
6758 }
6759
6760 blink = false;
6761 } else if( action == "MOVE_ZONE_UP" && zone_cnt > 1 ) {
6762 if( active_index < zone_cnt - 1 ) {
6763 mgr.swap( zones[active_index], zones[active_index + 1] );
6764 zones = get_zones();
6765 active_index++;
6766 }
6767 blink = false;
6768 stuff_changed = true;
6769
6770 } else if( action == "MOVE_ZONE_DOWN" && zone_cnt > 1 ) {
6771 if( active_index > 0 ) {
6772 mgr.swap( zones[active_index], zones[active_index - 1] );
6773 zones = get_zones();
6774 active_index--;
6775 }
6776 blink = false;
6777 stuff_changed = true;
6778
6779 } else if( action == "SHOW_ZONE_ON_MAP" ) {
6780 //show zone position on overmap;
6781 tripoint_abs_omt player_overmap_position = u.global_omt_location();
6782 // TODO: fix point types
6783 tripoint_abs_omt zone_overmap( ms_to_omt_copy( zones[active_index].get().get_center_point() ) );
6784
6785 ui::omap::display_zones( player_overmap_position, zone_overmap, active_index );
6786 } else if( action == "ENABLE_ZONE" ) {
6787 zones[active_index].get().set_enabled( true );
6788
6789 stuff_changed = true;
6790
6791 } else if( action == "DISABLE_ZONE" ) {
6792 zones[active_index].get().set_enabled( false );
6793
6794 stuff_changed = true;
6795 }
6796 }
6797
6798 if( zone_cnt > 0 ) {
6799 blink = !blink;
6800 const auto &zone = zones[active_index].get();
6801 zone_start = m.getlocal( zone.get_start_point() );
6802 zone_end = m.getlocal( zone.get_end_point() );
6803 ctxt.set_timeout( BLINK_SPEED );
6804 } else {
6805 blink = false;
6806 zone_start = zone_end = cata::nullopt;
6807 ctxt.reset_timeout();
6808 }
6809
6810 // Actually accessed from the terrain overlay callback `zone_cb` in the
6811 // call to `ui_manager::redraw`.
6812 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
6813 zone_blink = blink;
6815
6817
6818 //Wait for input
6819 action = ctxt.handle_input();
6820 } while( action != "QUIT" );
6821 zones_manager_open = false;
6822 ctxt.reset_timeout();
6823 zone_cb = nullptr;
6824
6825 if( stuff_changed ) {
6826 auto &zones = zone_manager::get_manager();
6827 if( query_yn( _( "Save changes?" ) ) ) {
6828 zones.save_zones();
6829 } else {
6830 zones.load_zones();
6831 }
6832
6833 zones.cache_data();
6834 }
6835
6836 u.view_offset = stored_view_offset;
6837}
query_popup & on_top(bool top)
Whether to show the popup on the top of the screen.
Definition: popup.cpp:59
std::reference_wrapper< zone_data > ref_zone_data
Definition: clzones.h:345
static shared_ptr_fast< zone_options > create(const zone_type_id &type)
Definition: clzones.cpp:185
int trig_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:512
static void zones_manager_shortcuts(const catacurses::window &w_info)
Definition: game.cpp:6312
static void zones_manager_draw_borders(const catacurses::window &w_border, const catacurses::window &w_info_border, const int iInfoHeight, const int width)
Definition: game.cpp:6335
std::string options()
Definition: path_info.cpp:238
const std::set< itype_id > & get()
void display_zones(const tripoint_abs_omt &center, const tripoint_abs_omt &select, int iZoneIndex)
Display overmap like with display() and display the given zone.
std::string trim_by_length(const std::string &text, int width)
Definition: output.cpp:224
cata::optional< tripoint > position
Definition: game.h:127

References _, action, add_draw_callback(), BLINK_SPEED, c_green, c_light_gray, c_light_green, c_white, c_yellow, calcStartPos(), center, zone_options::create(), create_zone_callback(), direction_from(), direction_name_short(), ui::omap::display_zones(), draw_scrollbar(), uilist::entries, g, charge_removal_blacklist::get(), zone_manager::get_manager(), map::getabs(), map::getlocal(), Character::global_omt_location(), input_context::handle_input(), invalidate_main_ui_adaptor(), look_around(), m, query_popup::message(), ms_to_omt_copy(), mvwprintz(), om_direction::name(), catacurses::newwin(), cata::nullopt, query_popup::on_top(), PATH_INFO::options(), point_south, point_zero, popup(), Character::pos(), look_around_result::position, uilist::query(), query_yn(), ui_manager::redraw(), input_context::register_action(), input_context::register_cardinal(), input_context::reset_timeout(), uilist::ret, rl_dist(), second, input_context::set_timeout(), TERMX, TERMY, uilist::text, trig_dist(), trim_by_length(), tripoint_zero, u, player::view_offset, catacurses::werase(), catacurses::wnoutrefresh(), tripoint::z, zones_manager_draw_borders(), zones_manager_open, and zones_manager_shortcuts().

Referenced by handle_action().

◆ zoom_in()

void game::zoom_in ( )

Definition at line 7331 of file game.cpp.

7332{
7333#if defined(TILES)
7334 if( tileset_zoom == 64 ) {
7335 tileset_zoom = MAXIMUM_ZOOM_LEVEL;
7336 } else {
7338 }
7339 rescale_tileset( tileset_zoom );
7340#endif
7341}

References tileset_zoom.

Referenced by handle_action(), and look_around().

◆ zoom_out()

void game::zoom_out ( )

Definition at line 7319 of file game.cpp.

7320{
7321#if defined(TILES)
7322 if( tileset_zoom > MAXIMUM_ZOOM_LEVEL ) {
7324 } else {
7325 tileset_zoom = 64;
7326 }
7327 rescale_tileset( tileset_zoom );
7328#endif
7329}

References tileset_zoom.

Referenced by handle_action(), and look_around().

Friends And Related Function Documentation

◆ advanced_inventory

friend class advanced_inventory
friend

Definition at line 146 of file game.h.

◆ Creature_range

friend class Creature_range
friend

Definition at line 360 of file game.h.

Referenced by all_creatures().

◆ editmap

friend class editmap
friend

Definition at line 145 of file game.h.

◆ get_avatar

avatar & get_avatar ( )
friend

Definition at line 102 of file avatar.cpp.

103{
104 return g->u;
105}

◆ get_distribution_grid_tracker

distribution_grid_tracker & get_distribution_grid_tracker ( )
friend

Returns distribution grid tracker that is a part of the global game *g.

game TODO: This wouldn't be required in an ideal world

Definition at line 12594 of file game.cpp.

12595{
12596 return *g->grid_tracker_ptr;
12597}

◆ get_map

map & get_map ( )
friend

Definition at line 142 of file map.cpp.

143{
144 return g->m;
145}

Referenced by check_art_charge_req(), extended_description(), find_empty_spot_nearby(), get_fire_fuel_string(), and print_terrain_info().

◆ get_player_character

Character & get_player_character ( )
friend

Definition at line 387 of file character.cpp.

388{
389 return g->u;
390}

◆ get_weather

weather_manager & get_weather ( )
friend

Definition at line 64 of file weather.cpp.

65{
66 return *g->weather_manager_ptr;
67}

Referenced by do_turn(), get_player_input(), is_in_sunlight(), load(), natural_light_level(), place_player_overmap(), serialize_master(), setup(), start_game(), and unserialize_master().

◆ main_menu

friend class main_menu
friend

Definition at line 147 of file game.h.

◆ monster_range

friend class monster_range
friend

Definition at line 359 of file game.h.

Referenced by all_monsters().

Member Data Documentation

◆ achievements_tracker_ptr

pimpl<achievements_tracker> game::achievements_tracker_ptr
private

Definition at line 1003 of file game.h.

Referenced by death_screen(), game(), handle_action(), serialize(), setup(), unserialize(), and win().

◆ active_npc

◆ auto_travel_mode

bool game::auto_travel_mode = false

Definition at line 1066 of file game.h.

Referenced by handle_action(), serialize(), and unserialize().

◆ bVMonsterLookFire

bool game::bVMonsterLookFire = false
private

Definition at line 1083 of file game.h.

Referenced by list_monsters(), look_around(), and setup().

◆ coming_to_stairs

std::vector<monster> game::coming_to_stairs

◆ critter_died

bool game::critter_died = false
private

Has anything died in this turn and needs to be cleaned up?

Definition at line 1097 of file game.h.

Referenced by cleanup_dead(), and set_critter_died().

◆ critter_tracker

◆ debug_hour_timer

◆ debug_pathfinding

bool game::debug_pathfinding = false

Definition at line 1047 of file game.h.

◆ debug_submap_grid_overlay

bool game::debug_submap_grid_overlay = false

Definition at line 1048 of file game.h.

◆ destination_preview

std::vector<tripoint> game::destination_preview
private

◆ displaying_lighting_condition

int game::displaying_lighting_condition = 0

Type of lighting condition overlay to display.

Definition at line 1060 of file game.h.

◆ displaying_overlays

cata::optional<action_id> game::displaying_overlays
private

Definition at line 967 of file game.h.

Referenced by display_overlay_state(), and display_toggle_overlay().

◆ displaying_visibility_creature

Creature* game::displaying_visibility_creature

Creature for which to display the visibility map.

Definition at line 1058 of file game.h.

Referenced by display_visibility().

◆ draw_callbacks

std::vector<weak_ptr_fast<draw_callback_t> > game::draw_callbacks
private

Definition at line 251 of file game.h.

Referenced by add_draw_callback(), and draw().

◆ driving_view_offset

point game::driving_view_offset

Definition at line 1045 of file game.h.

Referenced by calc_driving_offset(), do_turn(), handle_action(), and set_driving_view_offset().

◆ event_bus_ptr

pimpl<event_bus> game::event_bus_ptr
private

Definition at line 1001 of file game.h.

Referenced by events().

◆ faction_manager_ptr

◆ first_redraw_since_waiting_started

bool game::first_redraw_since_waiting_started = true
private

Is this the first redraw since waiting (sleeping or activity) started.

Definition at line 1099 of file game.h.

Referenced by do_turn(), and game().

◆ follower_ids

std::set<character_id> game::follower_ids
private

◆ fullscreen

bool game::fullscreen = false

◆ gamemode

std::unique_ptr<special_game> game::gamemode
private

◆ grid_tracker_ptr

pimpl<distribution_grid_tracker> game::grid_tracker_ptr
private

Definition at line 1007 of file game.h.

Referenced by do_turn(), load_map(), on_options_changed(), and update_map().

◆ is_looking

bool game::is_looking = false
private

Definition at line 250 of file game.h.

Referenced by draw_ter(), and look_around().

◆ kill_tracker_ptr

pimpl<kill_tracker> game::kill_tracker_ptr
private

Definition at line 1004 of file game.h.

Referenced by game(), get_kill_tracker(), serialize(), setup(), and unserialize().

◆ last_mouse_edge_scroll

std::chrono::time_point<std::chrono::steady_clock> game::last_mouse_edge_scroll
private

Definition at line 1116 of file game.h.

Referenced by mouse_edge_scrolling().

◆ last_mouse_edge_scroll_vector_overmap

tripoint game::last_mouse_edge_scroll_vector_overmap
private

Definition at line 1118 of file game.h.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ last_mouse_edge_scroll_vector_terrain

tripoint game::last_mouse_edge_scroll_vector_terrain
private

Definition at line 1117 of file game.h.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ last_save_timestamp

time_t game::last_save_timestamp
private

Definition at line 1089 of file game.h.

Referenced by autosave(), init_autosave(), and quicksave().

◆ latest_lightlevels

std::array<float, OVERMAP_LAYERS> game::latest_lightlevels
mutableprivate

Definition at line 1090 of file game.h.

Referenced by natural_light_level(), and reset_light_level().

◆ list_item_downvote

std::string game::list_item_downvote
private

Definition at line 1080 of file game.h.

Referenced by list_items().

◆ list_item_upvote

std::string game::list_item_upvote
private

Definition at line 1079 of file game.h.

Referenced by list_items().

◆ liveview

live_view& game::liveview
private

Definition at line 998 of file game.h.

Referenced by draw_look_around_cursor(), and handle_mouseview().

◆ liveview_ptr

pimpl<live_view> game::liveview_ptr
private

Definition at line 997 of file game.h.

◆ m

map& game::m

Definition at line 1011 of file game.h.

Referenced by autopilot_vehicles(), cata_event_dispatch::avatar_moves(), butcher(), catch_a_monster(), check_near_zone(), check_zone(), control_vehicle(), disable_robot(), disp_NPCs(), do_turn(), draw(), draw_bullet(), draw_critter(), draw_critter_highlighted(), draw_critter_internal(), draw_hit_mon(), draw_look_around_cursor(), draw_ter(), examine(), extended_description(), find_nearby_items(), find_or_make_stairs(), fling_creature(), forced_door_closing(), get_cur_om(), get_dangerous_tile(), get_fishable_locations(), get_levx(), get_levy(), get_levz(), get_player_input(), get_veh_dir_indicator_location(), grabbed_furn_move(), grabbed_veh_move(), handle_action(), is_empty(), is_game_over(), is_in_sunlight(), is_sheltered(), knockback(), list_items(), list_monsters(), load(), load_map(), load_npcs(), look_around(), mon_info_update(), monmove(), moving_vehicle_dismount(), peek(), perhaps_add_random_npc(), phasing_move(), pickup(), place_critter_around(), place_player(), place_player_overmap(), place_vehicle_nearby(), pre_print_all_tile_info(), print_all_tile_info(), print_fields_info(), print_graffiti_info(), print_items_info(), print_terrain_info(), print_trap_info(), process_artifact(), prompt_dangerous_tile(), remoteveh(), save_cyborg(), save_maps(), serialize(), setup(), shift_monsters(), start_game(), start_hauling(), swap_critters(), try_get_left_click_action(), try_get_right_click_action(), update_map(), update_stair_monsters(), use_computer(), validate_camps(), validate_linked_vehicles(), validate_mounted_npcs(), vertical_move(), vertical_notes(), vertical_shift(), walk_move(), wield(), and zones_manager().

◆ main_ui_adaptor

weak_ptr_fast<ui_adaptor> game::main_ui_adaptor
private

◆ map_ptr

pimpl<map> game::map_ptr
private

Definition at line 995 of file game.h.

◆ memorial_logger_ptr

pimpl<memorial_logger> game::memorial_logger_ptr
private

Definition at line 1005 of file game.h.

Referenced by game(), and memorial().

◆ monstairz

int game::monstairz = 0

Definition at line 1032 of file game.h.

Referenced by update_stair_monsters(), and vertical_move().

◆ mostseen

int game::mostseen = 0

◆ moves_since_last_save

int game::moves_since_last_save = 0
private

Definition at line 1088 of file game.h.

Referenced by do_turn(), get_moves_since_last_save(), init_autosave(), quickload(), and quicksave().

◆ new_game

bool game::new_game = false

True if the game has just started or loaded, else false.

Definition at line 1028 of file game.h.

Referenced by do_turn(), setup(), and start_game().

◆ next_mission_id

int game::next_mission_id = 0
private

Definition at line 1086 of file game.h.

Referenced by assign_mission_id(), serialize_master(), setup(), and unserialize_master().

◆ next_npc_id

character_id game::next_npc_id
private

Definition at line 1084 of file game.h.

Referenced by assign_npc_id(), serialize_master(), setup(), and unserialize_master().

◆ npcs_dirty

bool game::npcs_dirty = false
private

Has a NPC been spawned since last load?

Definition at line 1095 of file game.h.

Referenced by do_turn(), load_npcs(), and set_npcs_dirty().

◆ queue_screenshot

bool game::queue_screenshot = false

Definition at line 1067 of file game.h.

Referenced by do_turn().

◆ remoteveh_cache

vehicle* game::remoteveh_cache
private

Definition at line 1093 of file game.h.

Referenced by remoteveh(), setremoteveh(), and setup().

◆ remoteveh_cache_time

time_point game::remoteveh_cache_time
private

Definition at line 1092 of file game.h.

Referenced by remoteveh(), setremoteveh(), and setup().

◆ right_sidebar

bool game::right_sidebar = false

Definition at line 1063 of file game.h.

◆ safe_mode

◆ safe_mode_warning_logged

bool game::safe_mode_warning_logged = false
private

Definition at line 1082 of file game.h.

Referenced by check_safe_mode_allowed(), handle_action(), and set_safe_mode().

◆ scen

const scenario* game::scen

Definition at line 1030 of file game.h.

Referenced by start_calendar(), and start_game().

◆ scent

scent_map& game::scent

Definition at line 1013 of file game.h.

Referenced by display_scent(), do_turn(), serialize(), setup(), unserialize(), update_map(), and vertical_shift().

◆ scent_ptr

pimpl<scent_map> game::scent_ptr
private

Definition at line 999 of file game.h.

◆ seed

unsigned int game::seed = 0
private

Seed for all the random numbers that should have consistent randomness (weather).

Definition at line 1111 of file game.h.

Referenced by get_seed(), serialize_master(), start_game(), and unserialize_master().

◆ sFilter

std::string game::sFilter
private

Definition at line 1078 of file game.h.

Referenced by list_items(), and reset_item_list_state().

◆ show_panel_adm

bool game::show_panel_adm = false

Definition at line 1062 of file game.h.

Referenced by draw_panels(), and load_static_data().

◆ spell_events_ptr

pimpl<spell_events> game::spell_events_ptr
private

Definition at line 1006 of file game.h.

Referenced by game(), and spell_events_subscriber().

◆ stats_tracker_ptr

pimpl<stats_tracker> game::stats_tracker_ptr
private

Definition at line 1002 of file game.h.

Referenced by game(), serialize(), stats(), and unserialize().

◆ ter_view_p

tripoint game::ter_view_p

Definition at line 1034 of file game.h.

Referenced by draw(), and draw_ter().

◆ tileset_zoom

int game::tileset_zoom = 0
private

How far the tileset should be zoomed out, 16 is default.

32 is zoomed in by x2, 8 is zoomed out by x0.5

Definition at line 1108 of file game.h.

Referenced by get_zoom(), look_around(), mouse_edge_scrolling_terrain(), reset_zoom(), set_zoom(), zoom_in(), and zoom_out().

◆ timed_event_manager_ptr

pimpl<timed_event_manager> game::timed_event_manager_ptr
private

Definition at line 1000 of file game.h.

◆ timed_events

timed_event_manager& game::timed_events

Definition at line 1014 of file game.h.

Referenced by do_turn(), natural_light_level(), and setup().

◆ token_provider_ptr

pimpl<drop_token_provider> game::token_provider_ptr

Definition at line 1023 of file game.h.

Referenced by serialize(), setup(), and unserialize().

◆ turnssincelastmon

int game::turnssincelastmon = 0

Definition at line 1069 of file game.h.

Referenced by handle_action(), mon_info_update(), and setup().

◆ u

avatar& game::u

Definition at line 1012 of file game.h.

Referenced by add_npc_follower(), autopilot_vehicles(), cata_event_dispatch::avatar_moves(), butcher(), calc_driving_offset(), cancel_activity_or_ignore_query(), cancel_activity_query(), catch_a_monster(), centerlistview(), chat(), check_safe_mode_allowed(), cleanup_at_end(), control_vehicle(), create_starting_npcs(), critter_at(), critter_by_id(), disable_robot(), disp_NPCs(), display_scent(), do_turn(), draw(), draw_critter(), draw_critter_highlighted(), draw_critter_internal(), draw_hit_mon(), draw_line(), draw_look_around_cursor(), draw_minimap(), draw_panels(), draw_ter(), draw_trail_to_square(), draw_veh_dir_indicator(), drop(), drop_in_direction(), exam_vehicle(), examine(), extended_description(), favorite_ammo_or_select(), find_nearby_items(), find_or_make_stairs(), fling_creature(), forced_door_closing(), fungal_effects::fungalize(), get_dangerous_tile(), get_player_base_save_path(), get_player_input(), get_veh_dir_indicator_location(), grabbed_furn_move(), grabbed_move(), grabbed_veh_move(), handle_action(), handle_key_blocking_activity(), inv_map_splice(), inventory_item_menu(), is_game_over(), is_hostile_within(), is_in_viewport(), item_action_menu(), knockback(), list_items(), list_items_monsters(), list_missions(), list_monsters(), load(), look_around(), mon_info(), mon_info_update(), monmove(), move_save_to_graveyard(), moving_vehicle_dismount(), npc_menu(), on_move_effects(), open_consume_item_menu(), open_gate(), overmap_npc_move(), peek(), perhaps_add_random_npc(), phasing_move(), pickup_feet(), place_player(), place_player_overmap(), print_all_tile_info(), print_creature_info(), print_items_info(), print_terrain_info(), print_trap_info(), process_activity(), process_artifact(), process_voluntary_act_interrupt(), prompt_dangerous_tile(), quickload(), reload(), reload_item(), reload_weapon(), reload_wielded(), remoteveh(), remove_npc_follower(), save(), save_player_data(), serialize(), set_driving_view_offset(), setremoteveh(), shared_from(), slip_down(), fungal_effects::spread_fungus_one_tile(), start_game(), start_hauling(), try_get_left_click_action(), try_get_right_click_action(), unload(), unserialize(), update_map(), update_overmap_seen(), update_stair_monsters(), use_computer(), validate_camps(), validate_npc_followers(), vertical_move(), vertical_notes(), vertical_shift(), walk_move(), wield(), win(), win_screen(), and zones_manager().

◆ u_ptr

pimpl<avatar> game::u_ptr
private

Definition at line 996 of file game.h.

◆ u_shared_ptr

shared_ptr_fast<player> game::u_shared_ptr
private

Definition at line 1073 of file game.h.

Referenced by shared_from().

◆ uquit

quit_status game::uquit

Used in main.cpp to determine what type of quit is being performed.

Definition at line 1026 of file game.h.

Referenced by cleanup_at_end(), do_turn(), get_player_input(), handle_action(), is_game_over(), and setup().

◆ user_action_counter

int game::user_action_counter = 0
private

Definition at line 1105 of file game.h.

Referenced by get_user_action_counter(), and handle_action().

◆ w_minimap

catacurses::window game::w_minimap

Definition at line 1038 of file game.h.

Referenced by create_or_get_main_ui_adaptor(), and draw_minimap().

◆ w_minimap_ptr

catacurses::window game::w_minimap_ptr
private

Definition at line 1076 of file game.h.

Referenced by create_or_get_main_ui_adaptor().

◆ w_omlegend

catacurses::window game::w_omlegend

Definition at line 1037 of file game.h.

◆ w_overmap

catacurses::window game::w_overmap

Definition at line 1036 of file game.h.

◆ w_pixel_minimap

catacurses::window game::w_pixel_minimap

◆ w_terrain

◆ w_terrain_ptr

catacurses::window game::w_terrain_ptr
private

Definition at line 1075 of file game.h.

Referenced by create_or_get_main_ui_adaptor().

◆ wait_popup

std::unique_ptr<static_popup> game::wait_popup
private

Definition at line 1124 of file game.h.

Referenced by do_turn().

◆ was_fullscreen

bool game::was_fullscreen = false

Definition at line 1065 of file game.h.

Referenced by load_static_data(), reenter_fullscreen(), and temp_exit_fullscreen().

◆ weather_manager_ptr

pimpl<weather_manager> game::weather_manager_ptr
private

Definition at line 1008 of file game.h.

◆ zones_manager_open

bool game::zones_manager_open = false
private

Is Zone manager open or not - changes graphics of some zone tiles.

Definition at line 1101 of file game.h.

Referenced by is_zones_manager_open(), and zones_manager().


The documentation for this class was generated from the following files: